1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.shopping.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.annotation.BeanReference;
27  import com.liferay.portal.kernel.cache.CacheRegistry;
28  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
29  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
30  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
31  import com.liferay.portal.kernel.dao.orm.FinderPath;
32  import com.liferay.portal.kernel.dao.orm.Query;
33  import com.liferay.portal.kernel.dao.orm.QueryPos;
34  import com.liferay.portal.kernel.dao.orm.QueryUtil;
35  import com.liferay.portal.kernel.dao.orm.Session;
36  import com.liferay.portal.kernel.log.Log;
37  import com.liferay.portal.kernel.log.LogFactoryUtil;
38  import com.liferay.portal.kernel.util.GetterUtil;
39  import com.liferay.portal.kernel.util.OrderByComparator;
40  import com.liferay.portal.kernel.util.StringPool;
41  import com.liferay.portal.kernel.util.StringUtil;
42  import com.liferay.portal.kernel.util.Validator;
43  import com.liferay.portal.model.ModelListener;
44  import com.liferay.portal.service.persistence.BatchSessionUtil;
45  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
46  
47  import com.liferay.portlet.shopping.NoSuchOrderException;
48  import com.liferay.portlet.shopping.model.ShoppingOrder;
49  import com.liferay.portlet.shopping.model.impl.ShoppingOrderImpl;
50  import com.liferay.portlet.shopping.model.impl.ShoppingOrderModelImpl;
51  
52  import java.util.ArrayList;
53  import java.util.Collections;
54  import java.util.List;
55  
56  /**
57   * <a href="ShoppingOrderPersistenceImpl.java.html"><b><i>View Source</i></b></a>
58   *
59   * @author Brian Wing Shun Chan
60   *
61   */
62  public class ShoppingOrderPersistenceImpl extends BasePersistenceImpl
63      implements ShoppingOrderPersistence {
64      public static final String FINDER_CLASS_NAME_ENTITY = ShoppingOrderImpl.class.getName();
65      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
66          ".List";
67      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
68              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
69              FINDER_CLASS_NAME_LIST, "findByGroupId",
70              new String[] { Long.class.getName() });
71      public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
72              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
73              FINDER_CLASS_NAME_LIST, "findByGroupId",
74              new String[] {
75                  Long.class.getName(),
76                  
77              "java.lang.Integer", "java.lang.Integer",
78                  "com.liferay.portal.kernel.util.OrderByComparator"
79              });
80      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
81              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
82              FINDER_CLASS_NAME_LIST, "countByGroupId",
83              new String[] { Long.class.getName() });
84      public static final FinderPath FINDER_PATH_FETCH_BY_NUMBER = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
85              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
86              FINDER_CLASS_NAME_ENTITY, "fetchByNumber",
87              new String[] { String.class.getName() });
88      public static final FinderPath FINDER_PATH_COUNT_BY_NUMBER = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
89              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
90              FINDER_CLASS_NAME_LIST, "countByNumber",
91              new String[] { String.class.getName() });
92      public static final FinderPath FINDER_PATH_FETCH_BY_PPTXNID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
93              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
94              FINDER_CLASS_NAME_ENTITY, "fetchByPPTxnId",
95              new String[] { String.class.getName() });
96      public static final FinderPath FINDER_PATH_COUNT_BY_PPTXNID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
97              ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "countByPPTxnId",
99              new String[] { String.class.getName() });
100     public static final FinderPath FINDER_PATH_FIND_BY_G_U_PPPS = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
101             ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_LIST, "findByG_U_PPPS",
103             new String[] {
104                 Long.class.getName(), Long.class.getName(),
105                 String.class.getName()
106             });
107     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_U_PPPS = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
108             ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
109             FINDER_CLASS_NAME_LIST, "findByG_U_PPPS",
110             new String[] {
111                 Long.class.getName(), Long.class.getName(),
112                 String.class.getName(),
113                 
114             "java.lang.Integer", "java.lang.Integer",
115                 "com.liferay.portal.kernel.util.OrderByComparator"
116             });
117     public static final FinderPath FINDER_PATH_COUNT_BY_G_U_PPPS = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
118             ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
119             FINDER_CLASS_NAME_LIST, "countByG_U_PPPS",
120             new String[] {
121                 Long.class.getName(), Long.class.getName(),
122                 String.class.getName()
123             });
124     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
125             ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
126             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
127     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
128             ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
129             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
130 
131     public void cacheResult(ShoppingOrder shoppingOrder) {
132         EntityCacheUtil.putResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
133             ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey(),
134             shoppingOrder);
135 
136         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
137             new Object[] { shoppingOrder.getNumber() }, shoppingOrder);
138 
139         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
140             new Object[] { shoppingOrder.getPpTxnId() }, shoppingOrder);
141     }
142 
143     public void cacheResult(List<ShoppingOrder> shoppingOrders) {
144         for (ShoppingOrder shoppingOrder : shoppingOrders) {
145             if (EntityCacheUtil.getResult(
146                         ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
147                         ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey(),
148                         this) == null) {
149                 cacheResult(shoppingOrder);
150             }
151         }
152     }
153 
154     public void clearCache() {
155         CacheRegistry.clear(ShoppingOrderImpl.class.getName());
156         EntityCacheUtil.clearCache(ShoppingOrderImpl.class.getName());
157         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
158         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
159     }
160 
161     public ShoppingOrder create(long orderId) {
162         ShoppingOrder shoppingOrder = new ShoppingOrderImpl();
163 
164         shoppingOrder.setNew(true);
165         shoppingOrder.setPrimaryKey(orderId);
166 
167         return shoppingOrder;
168     }
169 
170     public ShoppingOrder remove(long orderId)
171         throws NoSuchOrderException, SystemException {
172         Session session = null;
173 
174         try {
175             session = openSession();
176 
177             ShoppingOrder shoppingOrder = (ShoppingOrder)session.get(ShoppingOrderImpl.class,
178                     new Long(orderId));
179 
180             if (shoppingOrder == null) {
181                 if (_log.isWarnEnabled()) {
182                     _log.warn("No ShoppingOrder exists with the primary key " +
183                         orderId);
184                 }
185 
186                 throw new NoSuchOrderException(
187                     "No ShoppingOrder exists with the primary key " + orderId);
188             }
189 
190             return remove(shoppingOrder);
191         }
192         catch (NoSuchOrderException nsee) {
193             throw nsee;
194         }
195         catch (Exception e) {
196             throw processException(e);
197         }
198         finally {
199             closeSession(session);
200         }
201     }
202 
203     public ShoppingOrder remove(ShoppingOrder shoppingOrder)
204         throws SystemException {
205         for (ModelListener<ShoppingOrder> listener : listeners) {
206             listener.onBeforeRemove(shoppingOrder);
207         }
208 
209         shoppingOrder = removeImpl(shoppingOrder);
210 
211         for (ModelListener<ShoppingOrder> listener : listeners) {
212             listener.onAfterRemove(shoppingOrder);
213         }
214 
215         return shoppingOrder;
216     }
217 
218     protected ShoppingOrder removeImpl(ShoppingOrder shoppingOrder)
219         throws SystemException {
220         Session session = null;
221 
222         try {
223             session = openSession();
224 
225             if (shoppingOrder.isCachedModel() || BatchSessionUtil.isEnabled()) {
226                 Object staleObject = session.get(ShoppingOrderImpl.class,
227                         shoppingOrder.getPrimaryKeyObj());
228 
229                 if (staleObject != null) {
230                     session.evict(staleObject);
231                 }
232             }
233 
234             session.delete(shoppingOrder);
235 
236             session.flush();
237         }
238         catch (Exception e) {
239             throw processException(e);
240         }
241         finally {
242             closeSession(session);
243         }
244 
245         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
246 
247         ShoppingOrderModelImpl shoppingOrderModelImpl = (ShoppingOrderModelImpl)shoppingOrder;
248 
249         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_NUMBER,
250             new Object[] { shoppingOrderModelImpl.getOriginalNumber() });
251 
252         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_PPTXNID,
253             new Object[] { shoppingOrderModelImpl.getOriginalPpTxnId() });
254 
255         EntityCacheUtil.removeResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
256             ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey());
257 
258         return shoppingOrder;
259     }
260 
261     /**
262      * @deprecated Use <code>update(ShoppingOrder shoppingOrder, boolean merge)</code>.
263      */
264     public ShoppingOrder update(ShoppingOrder shoppingOrder)
265         throws SystemException {
266         if (_log.isWarnEnabled()) {
267             _log.warn(
268                 "Using the deprecated update(ShoppingOrder shoppingOrder) method. Use update(ShoppingOrder shoppingOrder, boolean merge) instead.");
269         }
270 
271         return update(shoppingOrder, false);
272     }
273 
274     /**
275      * Add, update, or merge, the entity. This method also calls the model
276      * listeners to trigger the proper events associated with adding, deleting,
277      * or updating an entity.
278      *
279      * @param        shoppingOrder the entity to add, update, or merge
280      * @param        merge boolean value for whether to merge the entity. The
281      *                default value is false. Setting merge to true is more
282      *                expensive and should only be true when shoppingOrder is
283      *                transient. See LEP-5473 for a detailed discussion of this
284      *                method.
285      * @return        true if the portlet can be displayed via Ajax
286      */
287     public ShoppingOrder update(ShoppingOrder shoppingOrder, boolean merge)
288         throws SystemException {
289         boolean isNew = shoppingOrder.isNew();
290 
291         for (ModelListener<ShoppingOrder> listener : listeners) {
292             if (isNew) {
293                 listener.onBeforeCreate(shoppingOrder);
294             }
295             else {
296                 listener.onBeforeUpdate(shoppingOrder);
297             }
298         }
299 
300         shoppingOrder = updateImpl(shoppingOrder, merge);
301 
302         for (ModelListener<ShoppingOrder> listener : listeners) {
303             if (isNew) {
304                 listener.onAfterCreate(shoppingOrder);
305             }
306             else {
307                 listener.onAfterUpdate(shoppingOrder);
308             }
309         }
310 
311         return shoppingOrder;
312     }
313 
314     public ShoppingOrder updateImpl(
315         com.liferay.portlet.shopping.model.ShoppingOrder shoppingOrder,
316         boolean merge) throws SystemException {
317         boolean isNew = shoppingOrder.isNew();
318 
319         ShoppingOrderModelImpl shoppingOrderModelImpl = (ShoppingOrderModelImpl)shoppingOrder;
320 
321         Session session = null;
322 
323         try {
324             session = openSession();
325 
326             BatchSessionUtil.update(session, shoppingOrder, merge);
327 
328             shoppingOrder.setNew(false);
329         }
330         catch (Exception e) {
331             throw processException(e);
332         }
333         finally {
334             closeSession(session);
335         }
336 
337         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
338 
339         EntityCacheUtil.putResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
340             ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey(),
341             shoppingOrder);
342 
343         if (!isNew &&
344                 (!Validator.equals(shoppingOrder.getNumber(),
345                     shoppingOrderModelImpl.getOriginalNumber()))) {
346             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_NUMBER,
347                 new Object[] { shoppingOrderModelImpl.getOriginalNumber() });
348         }
349 
350         if (isNew ||
351                 (!Validator.equals(shoppingOrder.getNumber(),
352                     shoppingOrderModelImpl.getOriginalNumber()))) {
353             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
354                 new Object[] { shoppingOrder.getNumber() }, shoppingOrder);
355         }
356 
357         if (!isNew &&
358                 (!Validator.equals(shoppingOrder.getPpTxnId(),
359                     shoppingOrderModelImpl.getOriginalPpTxnId()))) {
360             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_PPTXNID,
361                 new Object[] { shoppingOrderModelImpl.getOriginalPpTxnId() });
362         }
363 
364         if (isNew ||
365                 (!Validator.equals(shoppingOrder.getPpTxnId(),
366                     shoppingOrderModelImpl.getOriginalPpTxnId()))) {
367             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
368                 new Object[] { shoppingOrder.getPpTxnId() }, shoppingOrder);
369         }
370 
371         return shoppingOrder;
372     }
373 
374     public ShoppingOrder findByPrimaryKey(long orderId)
375         throws NoSuchOrderException, SystemException {
376         ShoppingOrder shoppingOrder = fetchByPrimaryKey(orderId);
377 
378         if (shoppingOrder == null) {
379             if (_log.isWarnEnabled()) {
380                 _log.warn("No ShoppingOrder exists with the primary key " +
381                     orderId);
382             }
383 
384             throw new NoSuchOrderException(
385                 "No ShoppingOrder exists with the primary key " + orderId);
386         }
387 
388         return shoppingOrder;
389     }
390 
391     public ShoppingOrder fetchByPrimaryKey(long orderId)
392         throws SystemException {
393         ShoppingOrder shoppingOrder = (ShoppingOrder)EntityCacheUtil.getResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
394                 ShoppingOrderImpl.class, orderId, this);
395 
396         if (shoppingOrder == null) {
397             Session session = null;
398 
399             try {
400                 session = openSession();
401 
402                 shoppingOrder = (ShoppingOrder)session.get(ShoppingOrderImpl.class,
403                         new Long(orderId));
404             }
405             catch (Exception e) {
406                 throw processException(e);
407             }
408             finally {
409                 if (shoppingOrder != null) {
410                     cacheResult(shoppingOrder);
411                 }
412 
413                 closeSession(session);
414             }
415         }
416 
417         return shoppingOrder;
418     }
419 
420     public List<ShoppingOrder> findByGroupId(long groupId)
421         throws SystemException {
422         Object[] finderArgs = new Object[] { new Long(groupId) };
423 
424         List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
425                 finderArgs, this);
426 
427         if (list == null) {
428             Session session = null;
429 
430             try {
431                 session = openSession();
432 
433                 StringBuilder query = new StringBuilder();
434 
435                 query.append(
436                     "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
437 
438                 query.append("shoppingOrder.groupId = ?");
439 
440                 query.append(" ");
441 
442                 query.append("ORDER BY ");
443 
444                 query.append("shoppingOrder.createDate DESC");
445 
446                 Query q = session.createQuery(query.toString());
447 
448                 QueryPos qPos = QueryPos.getInstance(q);
449 
450                 qPos.add(groupId);
451 
452                 list = q.list();
453             }
454             catch (Exception e) {
455                 throw processException(e);
456             }
457             finally {
458                 if (list == null) {
459                     list = new ArrayList<ShoppingOrder>();
460                 }
461 
462                 cacheResult(list);
463 
464                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
465                     finderArgs, list);
466 
467                 closeSession(session);
468             }
469         }
470 
471         return list;
472     }
473 
474     public List<ShoppingOrder> findByGroupId(long groupId, int start, int end)
475         throws SystemException {
476         return findByGroupId(groupId, start, end, null);
477     }
478 
479     public List<ShoppingOrder> findByGroupId(long groupId, int start, int end,
480         OrderByComparator obc) throws SystemException {
481         Object[] finderArgs = new Object[] {
482                 new Long(groupId),
483                 
484                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
485             };
486 
487         List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
488                 finderArgs, this);
489 
490         if (list == null) {
491             Session session = null;
492 
493             try {
494                 session = openSession();
495 
496                 StringBuilder query = new StringBuilder();
497 
498                 query.append(
499                     "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
500 
501                 query.append("shoppingOrder.groupId = ?");
502 
503                 query.append(" ");
504 
505                 if (obc != null) {
506                     query.append("ORDER BY ");
507 
508                     String[] orderByFields = obc.getOrderByFields();
509 
510                     for (int i = 0; i < orderByFields.length; i++) {
511                         query.append("shoppingOrder.");
512                         query.append(orderByFields[i]);
513 
514                         if (obc.isAscending()) {
515                             query.append(" ASC");
516                         }
517                         else {
518                             query.append(" DESC");
519                         }
520 
521                         if ((i + 1) < orderByFields.length) {
522                             query.append(", ");
523                         }
524                     }
525                 }
526 
527                 else {
528                     query.append("ORDER BY ");
529 
530                     query.append("shoppingOrder.createDate DESC");
531                 }
532 
533                 Query q = session.createQuery(query.toString());
534 
535                 QueryPos qPos = QueryPos.getInstance(q);
536 
537                 qPos.add(groupId);
538 
539                 list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
540                         start, end);
541             }
542             catch (Exception e) {
543                 throw processException(e);
544             }
545             finally {
546                 if (list == null) {
547                     list = new ArrayList<ShoppingOrder>();
548                 }
549 
550                 cacheResult(list);
551 
552                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
553                     finderArgs, list);
554 
555                 closeSession(session);
556             }
557         }
558 
559         return list;
560     }
561 
562     public ShoppingOrder findByGroupId_First(long groupId, OrderByComparator obc)
563         throws NoSuchOrderException, SystemException {
564         List<ShoppingOrder> list = findByGroupId(groupId, 0, 1, obc);
565 
566         if (list.isEmpty()) {
567             StringBuilder msg = new StringBuilder();
568 
569             msg.append("No ShoppingOrder exists with the key {");
570 
571             msg.append("groupId=" + groupId);
572 
573             msg.append(StringPool.CLOSE_CURLY_BRACE);
574 
575             throw new NoSuchOrderException(msg.toString());
576         }
577         else {
578             return list.get(0);
579         }
580     }
581 
582     public ShoppingOrder findByGroupId_Last(long groupId, OrderByComparator obc)
583         throws NoSuchOrderException, SystemException {
584         int count = countByGroupId(groupId);
585 
586         List<ShoppingOrder> list = findByGroupId(groupId, count - 1, count, obc);
587 
588         if (list.isEmpty()) {
589             StringBuilder msg = new StringBuilder();
590 
591             msg.append("No ShoppingOrder exists with the key {");
592 
593             msg.append("groupId=" + groupId);
594 
595             msg.append(StringPool.CLOSE_CURLY_BRACE);
596 
597             throw new NoSuchOrderException(msg.toString());
598         }
599         else {
600             return list.get(0);
601         }
602     }
603 
604     public ShoppingOrder[] findByGroupId_PrevAndNext(long orderId,
605         long groupId, OrderByComparator obc)
606         throws NoSuchOrderException, SystemException {
607         ShoppingOrder shoppingOrder = findByPrimaryKey(orderId);
608 
609         int count = countByGroupId(groupId);
610 
611         Session session = null;
612 
613         try {
614             session = openSession();
615 
616             StringBuilder query = new StringBuilder();
617 
618             query.append(
619                 "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
620 
621             query.append("shoppingOrder.groupId = ?");
622 
623             query.append(" ");
624 
625             if (obc != null) {
626                 query.append("ORDER BY ");
627 
628                 String[] orderByFields = obc.getOrderByFields();
629 
630                 for (int i = 0; i < orderByFields.length; i++) {
631                     query.append("shoppingOrder.");
632                     query.append(orderByFields[i]);
633 
634                     if (obc.isAscending()) {
635                         query.append(" ASC");
636                     }
637                     else {
638                         query.append(" DESC");
639                     }
640 
641                     if ((i + 1) < orderByFields.length) {
642                         query.append(", ");
643                     }
644                 }
645             }
646 
647             else {
648                 query.append("ORDER BY ");
649 
650                 query.append("shoppingOrder.createDate DESC");
651             }
652 
653             Query q = session.createQuery(query.toString());
654 
655             QueryPos qPos = QueryPos.getInstance(q);
656 
657             qPos.add(groupId);
658 
659             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
660                     shoppingOrder);
661 
662             ShoppingOrder[] array = new ShoppingOrderImpl[3];
663 
664             array[0] = (ShoppingOrder)objArray[0];
665             array[1] = (ShoppingOrder)objArray[1];
666             array[2] = (ShoppingOrder)objArray[2];
667 
668             return array;
669         }
670         catch (Exception e) {
671             throw processException(e);
672         }
673         finally {
674             closeSession(session);
675         }
676     }
677 
678     public ShoppingOrder findByNumber(String number)
679         throws NoSuchOrderException, SystemException {
680         ShoppingOrder shoppingOrder = fetchByNumber(number);
681 
682         if (shoppingOrder == null) {
683             StringBuilder msg = new StringBuilder();
684 
685             msg.append("No ShoppingOrder exists with the key {");
686 
687             msg.append("number=" + number);
688 
689             msg.append(StringPool.CLOSE_CURLY_BRACE);
690 
691             if (_log.isWarnEnabled()) {
692                 _log.warn(msg.toString());
693             }
694 
695             throw new NoSuchOrderException(msg.toString());
696         }
697 
698         return shoppingOrder;
699     }
700 
701     public ShoppingOrder fetchByNumber(String number) throws SystemException {
702         return fetchByNumber(number, true);
703     }
704 
705     public ShoppingOrder fetchByNumber(String number, boolean retrieveFromCache)
706         throws SystemException {
707         Object[] finderArgs = new Object[] { number };
708 
709         Object result = null;
710 
711         if (retrieveFromCache) {
712             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_NUMBER,
713                     finderArgs, this);
714         }
715 
716         if (result == null) {
717             Session session = null;
718 
719             try {
720                 session = openSession();
721 
722                 StringBuilder query = new StringBuilder();
723 
724                 query.append(
725                     "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
726 
727                 if (number == null) {
728                     query.append("shoppingOrder.number IS NULL");
729                 }
730                 else {
731                     query.append("shoppingOrder.number = ?");
732                 }
733 
734                 query.append(" ");
735 
736                 query.append("ORDER BY ");
737 
738                 query.append("shoppingOrder.createDate DESC");
739 
740                 Query q = session.createQuery(query.toString());
741 
742                 QueryPos qPos = QueryPos.getInstance(q);
743 
744                 if (number != null) {
745                     qPos.add(number);
746                 }
747 
748                 List<ShoppingOrder> list = q.list();
749 
750                 result = list;
751 
752                 ShoppingOrder shoppingOrder = null;
753 
754                 if (list.isEmpty()) {
755                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
756                         finderArgs, list);
757                 }
758                 else {
759                     shoppingOrder = list.get(0);
760 
761                     cacheResult(shoppingOrder);
762 
763                     if ((shoppingOrder.getNumber() == null) ||
764                             !shoppingOrder.getNumber().equals(number)) {
765                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
766                             finderArgs, shoppingOrder);
767                     }
768                 }
769 
770                 return shoppingOrder;
771             }
772             catch (Exception e) {
773                 throw processException(e);
774             }
775             finally {
776                 if (result == null) {
777                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
778                         finderArgs, new ArrayList<ShoppingOrder>());
779                 }
780 
781                 closeSession(session);
782             }
783         }
784         else {
785             if (result instanceof List) {
786                 return null;
787             }
788             else {
789                 return (ShoppingOrder)result;
790             }
791         }
792     }
793 
794     public ShoppingOrder findByPPTxnId(String ppTxnId)
795         throws NoSuchOrderException, SystemException {
796         ShoppingOrder shoppingOrder = fetchByPPTxnId(ppTxnId);
797 
798         if (shoppingOrder == null) {
799             StringBuilder msg = new StringBuilder();
800 
801             msg.append("No ShoppingOrder exists with the key {");
802 
803             msg.append("ppTxnId=" + ppTxnId);
804 
805             msg.append(StringPool.CLOSE_CURLY_BRACE);
806 
807             if (_log.isWarnEnabled()) {
808                 _log.warn(msg.toString());
809             }
810 
811             throw new NoSuchOrderException(msg.toString());
812         }
813 
814         return shoppingOrder;
815     }
816 
817     public ShoppingOrder fetchByPPTxnId(String ppTxnId)
818         throws SystemException {
819         return fetchByPPTxnId(ppTxnId, true);
820     }
821 
822     public ShoppingOrder fetchByPPTxnId(String ppTxnId,
823         boolean retrieveFromCache) throws SystemException {
824         Object[] finderArgs = new Object[] { ppTxnId };
825 
826         Object result = null;
827 
828         if (retrieveFromCache) {
829             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_PPTXNID,
830                     finderArgs, this);
831         }
832 
833         if (result == null) {
834             Session session = null;
835 
836             try {
837                 session = openSession();
838 
839                 StringBuilder query = new StringBuilder();
840 
841                 query.append(
842                     "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
843 
844                 if (ppTxnId == null) {
845                     query.append("shoppingOrder.ppTxnId IS NULL");
846                 }
847                 else {
848                     query.append("shoppingOrder.ppTxnId = ?");
849                 }
850 
851                 query.append(" ");
852 
853                 query.append("ORDER BY ");
854 
855                 query.append("shoppingOrder.createDate DESC");
856 
857                 Query q = session.createQuery(query.toString());
858 
859                 QueryPos qPos = QueryPos.getInstance(q);
860 
861                 if (ppTxnId != null) {
862                     qPos.add(ppTxnId);
863                 }
864 
865                 List<ShoppingOrder> list = q.list();
866 
867                 result = list;
868 
869                 ShoppingOrder shoppingOrder = null;
870 
871                 if (list.isEmpty()) {
872                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
873                         finderArgs, list);
874                 }
875                 else {
876                     shoppingOrder = list.get(0);
877 
878                     cacheResult(shoppingOrder);
879 
880                     if ((shoppingOrder.getPpTxnId() == null) ||
881                             !shoppingOrder.getPpTxnId().equals(ppTxnId)) {
882                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
883                             finderArgs, shoppingOrder);
884                     }
885                 }
886 
887                 return shoppingOrder;
888             }
889             catch (Exception e) {
890                 throw processException(e);
891             }
892             finally {
893                 if (result == null) {
894                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
895                         finderArgs, new ArrayList<ShoppingOrder>());
896                 }
897 
898                 closeSession(session);
899             }
900         }
901         else {
902             if (result instanceof List) {
903                 return null;
904             }
905             else {
906                 return (ShoppingOrder)result;
907             }
908         }
909     }
910 
911     public List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId,
912         String ppPaymentStatus) throws SystemException {
913         Object[] finderArgs = new Object[] {
914                 new Long(groupId), new Long(userId),
915                 
916                 ppPaymentStatus
917             };
918 
919         List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_PPPS,
920                 finderArgs, this);
921 
922         if (list == null) {
923             Session session = null;
924 
925             try {
926                 session = openSession();
927 
928                 StringBuilder query = new StringBuilder();
929 
930                 query.append(
931                     "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
932 
933                 query.append("shoppingOrder.groupId = ?");
934 
935                 query.append(" AND ");
936 
937                 query.append("shoppingOrder.userId = ?");
938 
939                 query.append(" AND ");
940 
941                 if (ppPaymentStatus == null) {
942                     query.append("shoppingOrder.ppPaymentStatus IS NULL");
943                 }
944                 else {
945                     query.append("shoppingOrder.ppPaymentStatus = ?");
946                 }
947 
948                 query.append(" ");
949 
950                 query.append("ORDER BY ");
951 
952                 query.append("shoppingOrder.createDate DESC");
953 
954                 Query q = session.createQuery(query.toString());
955 
956                 QueryPos qPos = QueryPos.getInstance(q);
957 
958                 qPos.add(groupId);
959 
960                 qPos.add(userId);
961 
962                 if (ppPaymentStatus != null) {
963                     qPos.add(ppPaymentStatus);
964                 }
965 
966                 list = q.list();
967             }
968             catch (Exception e) {
969                 throw processException(e);
970             }
971             finally {
972                 if (list == null) {
973                     list = new ArrayList<ShoppingOrder>();
974                 }
975 
976                 cacheResult(list);
977 
978                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_PPPS,
979                     finderArgs, list);
980 
981                 closeSession(session);
982             }
983         }
984 
985         return list;
986     }
987 
988     public List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId,
989         String ppPaymentStatus, int start, int end) throws SystemException {
990         return findByG_U_PPPS(groupId, userId, ppPaymentStatus, start, end, null);
991     }
992 
993     public List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId,
994         String ppPaymentStatus, int start, int end, OrderByComparator obc)
995         throws SystemException {
996         Object[] finderArgs = new Object[] {
997                 new Long(groupId), new Long(userId),
998                 
999                 ppPaymentStatus,
1000                
1001                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1002            };
1003
1004        List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_U_PPPS,
1005                finderArgs, this);
1006
1007        if (list == null) {
1008            Session session = null;
1009
1010            try {
1011                session = openSession();
1012
1013                StringBuilder query = new StringBuilder();
1014
1015                query.append(
1016                    "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
1017
1018                query.append("shoppingOrder.groupId = ?");
1019
1020                query.append(" AND ");
1021
1022                query.append("shoppingOrder.userId = ?");
1023
1024                query.append(" AND ");
1025
1026                if (ppPaymentStatus == null) {
1027                    query.append("shoppingOrder.ppPaymentStatus IS NULL");
1028                }
1029                else {
1030                    query.append("shoppingOrder.ppPaymentStatus = ?");
1031                }
1032
1033                query.append(" ");
1034
1035                if (obc != null) {
1036                    query.append("ORDER BY ");
1037
1038                    String[] orderByFields = obc.getOrderByFields();
1039
1040                    for (int i = 0; i < orderByFields.length; i++) {
1041                        query.append("shoppingOrder.");
1042                        query.append(orderByFields[i]);
1043
1044                        if (obc.isAscending()) {
1045                            query.append(" ASC");
1046                        }
1047                        else {
1048                            query.append(" DESC");
1049                        }
1050
1051                        if ((i + 1) < orderByFields.length) {
1052                            query.append(", ");
1053                        }
1054                    }
1055                }
1056
1057                else {
1058                    query.append("ORDER BY ");
1059
1060                    query.append("shoppingOrder.createDate DESC");
1061                }
1062
1063                Query q = session.createQuery(query.toString());
1064
1065                QueryPos qPos = QueryPos.getInstance(q);
1066
1067                qPos.add(groupId);
1068
1069                qPos.add(userId);
1070
1071                if (ppPaymentStatus != null) {
1072                    qPos.add(ppPaymentStatus);
1073                }
1074
1075                list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
1076                        start, end);
1077            }
1078            catch (Exception e) {
1079                throw processException(e);
1080            }
1081            finally {
1082                if (list == null) {
1083                    list = new ArrayList<ShoppingOrder>();
1084                }
1085
1086                cacheResult(list);
1087
1088                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_U_PPPS,
1089                    finderArgs, list);
1090
1091                closeSession(session);
1092            }
1093        }
1094
1095        return list;
1096    }
1097
1098    public ShoppingOrder findByG_U_PPPS_First(long groupId, long userId,
1099        String ppPaymentStatus, OrderByComparator obc)
1100        throws NoSuchOrderException, SystemException {
1101        List<ShoppingOrder> list = findByG_U_PPPS(groupId, userId,
1102                ppPaymentStatus, 0, 1, obc);
1103
1104        if (list.isEmpty()) {
1105            StringBuilder msg = new StringBuilder();
1106
1107            msg.append("No ShoppingOrder exists with the key {");
1108
1109            msg.append("groupId=" + groupId);
1110
1111            msg.append(", ");
1112            msg.append("userId=" + userId);
1113
1114            msg.append(", ");
1115            msg.append("ppPaymentStatus=" + ppPaymentStatus);
1116
1117            msg.append(StringPool.CLOSE_CURLY_BRACE);
1118
1119            throw new NoSuchOrderException(msg.toString());
1120        }
1121        else {
1122            return list.get(0);
1123        }
1124    }
1125
1126    public ShoppingOrder findByG_U_PPPS_Last(long groupId, long userId,
1127        String ppPaymentStatus, OrderByComparator obc)
1128        throws NoSuchOrderException, SystemException {
1129        int count = countByG_U_PPPS(groupId, userId, ppPaymentStatus);
1130
1131        List<ShoppingOrder> list = findByG_U_PPPS(groupId, userId,
1132                ppPaymentStatus, count - 1, count, obc);
1133
1134        if (list.isEmpty()) {
1135            StringBuilder msg = new StringBuilder();
1136
1137            msg.append("No ShoppingOrder exists with the key {");
1138
1139            msg.append("groupId=" + groupId);
1140
1141            msg.append(", ");
1142            msg.append("userId=" + userId);
1143
1144            msg.append(", ");
1145            msg.append("ppPaymentStatus=" + ppPaymentStatus);
1146
1147            msg.append(StringPool.CLOSE_CURLY_BRACE);
1148
1149            throw new NoSuchOrderException(msg.toString());
1150        }
1151        else {
1152            return list.get(0);
1153        }
1154    }
1155
1156    public ShoppingOrder[] findByG_U_PPPS_PrevAndNext(long orderId,
1157        long groupId, long userId, String ppPaymentStatus, OrderByComparator obc)
1158        throws NoSuchOrderException, SystemException {
1159        ShoppingOrder shoppingOrder = findByPrimaryKey(orderId);
1160
1161        int count = countByG_U_PPPS(groupId, userId, ppPaymentStatus);
1162
1163        Session session = null;
1164
1165        try {
1166            session = openSession();
1167
1168            StringBuilder query = new StringBuilder();
1169
1170            query.append(
1171                "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ");
1172
1173            query.append("shoppingOrder.groupId = ?");
1174
1175            query.append(" AND ");
1176
1177            query.append("shoppingOrder.userId = ?");
1178
1179            query.append(" AND ");
1180
1181            if (ppPaymentStatus == null) {
1182                query.append("shoppingOrder.ppPaymentStatus IS NULL");
1183            }
1184            else {
1185                query.append("shoppingOrder.ppPaymentStatus = ?");
1186            }
1187
1188            query.append(" ");
1189
1190            if (obc != null) {
1191                query.append("ORDER BY ");
1192
1193                String[] orderByFields = obc.getOrderByFields();
1194
1195                for (int i = 0; i < orderByFields.length; i++) {
1196                    query.append("shoppingOrder.");
1197                    query.append(orderByFields[i]);
1198
1199                    if (obc.isAscending()) {
1200                        query.append(" ASC");
1201                    }
1202                    else {
1203                        query.append(" DESC");
1204                    }
1205
1206                    if ((i + 1) < orderByFields.length) {
1207                        query.append(", ");
1208                    }
1209                }
1210            }
1211
1212            else {
1213                query.append("ORDER BY ");
1214
1215                query.append("shoppingOrder.createDate DESC");
1216            }
1217
1218            Query q = session.createQuery(query.toString());
1219
1220            QueryPos qPos = QueryPos.getInstance(q);
1221
1222            qPos.add(groupId);
1223
1224            qPos.add(userId);
1225
1226            if (ppPaymentStatus != null) {
1227                qPos.add(ppPaymentStatus);
1228            }
1229
1230            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1231                    shoppingOrder);
1232
1233            ShoppingOrder[] array = new ShoppingOrderImpl[3];
1234
1235            array[0] = (ShoppingOrder)objArray[0];
1236            array[1] = (ShoppingOrder)objArray[1];
1237            array[2] = (ShoppingOrder)objArray[2];
1238
1239            return array;
1240        }
1241        catch (Exception e) {
1242            throw processException(e);
1243        }
1244        finally {
1245            closeSession(session);
1246        }
1247    }
1248
1249    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1250        throws SystemException {
1251        Session session = null;
1252
1253        try {
1254            session = openSession();
1255
1256            dynamicQuery.compile(session);
1257
1258            return dynamicQuery.list();
1259        }
1260        catch (Exception e) {
1261            throw processException(e);
1262        }
1263        finally {
1264            closeSession(session);
1265        }
1266    }
1267
1268    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1269        int start, int end) throws SystemException {
1270        Session session = null;
1271
1272        try {
1273            session = openSession();
1274
1275            dynamicQuery.setLimit(start, end);
1276
1277            dynamicQuery.compile(session);
1278
1279            return dynamicQuery.list();
1280        }
1281        catch (Exception e) {
1282            throw processException(e);
1283        }
1284        finally {
1285            closeSession(session);
1286        }
1287    }
1288
1289    public List<ShoppingOrder> findAll() throws SystemException {
1290        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1291    }
1292
1293    public List<ShoppingOrder> findAll(int start, int end)
1294        throws SystemException {
1295        return findAll(start, end, null);
1296    }
1297
1298    public List<ShoppingOrder> findAll(int start, int end, OrderByComparator obc)
1299        throws SystemException {
1300        Object[] finderArgs = new Object[] {
1301                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1302            };
1303
1304        List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1305                finderArgs, this);
1306
1307        if (list == null) {
1308            Session session = null;
1309
1310            try {
1311                session = openSession();
1312
1313                StringBuilder query = new StringBuilder();
1314
1315                query.append(
1316                    "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder ");
1317
1318                if (obc != null) {
1319                    query.append("ORDER BY ");
1320
1321                    String[] orderByFields = obc.getOrderByFields();
1322
1323                    for (int i = 0; i < orderByFields.length; i++) {
1324                        query.append("shoppingOrder.");
1325                        query.append(orderByFields[i]);
1326
1327                        if (obc.isAscending()) {
1328                            query.append(" ASC");
1329                        }
1330                        else {
1331                            query.append(" DESC");
1332                        }
1333
1334                        if ((i + 1) < orderByFields.length) {
1335                            query.append(", ");
1336                        }
1337                    }
1338                }
1339
1340                else {
1341                    query.append("ORDER BY ");
1342
1343                    query.append("shoppingOrder.createDate DESC");
1344                }
1345
1346                Query q = session.createQuery(query.toString());
1347
1348                if (obc == null) {
1349                    list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
1350                            start, end, false);
1351
1352                    Collections.sort(list);
1353                }
1354                else {
1355                    list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
1356                            start, end);
1357                }
1358            }
1359            catch (Exception e) {
1360                throw processException(e);
1361            }
1362            finally {
1363                if (list == null) {
1364                    list = new ArrayList<ShoppingOrder>();
1365                }
1366
1367                cacheResult(list);
1368
1369                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1370
1371                closeSession(session);
1372            }
1373        }
1374
1375        return list;
1376    }
1377
1378    public void removeByGroupId(long groupId) throws SystemException {
1379        for (ShoppingOrder shoppingOrder : findByGroupId(groupId)) {
1380            remove(shoppingOrder);
1381        }
1382    }
1383
1384    public void removeByNumber(String number)
1385        throws NoSuchOrderException, SystemException {
1386        ShoppingOrder shoppingOrder = findByNumber(number);
1387
1388        remove(shoppingOrder);
1389    }
1390
1391    public void removeByPPTxnId(String ppTxnId)
1392        throws NoSuchOrderException, SystemException {
1393        ShoppingOrder shoppingOrder = findByPPTxnId(ppTxnId);
1394
1395        remove(shoppingOrder);
1396    }
1397
1398    public void removeByG_U_PPPS(long groupId, long userId,
1399        String ppPaymentStatus) throws SystemException {
1400        for (ShoppingOrder shoppingOrder : findByG_U_PPPS(groupId, userId,
1401                ppPaymentStatus)) {
1402            remove(shoppingOrder);
1403        }
1404    }
1405
1406    public void removeAll() throws SystemException {
1407        for (ShoppingOrder shoppingOrder : findAll()) {
1408            remove(shoppingOrder);
1409        }
1410    }
1411
1412    public int countByGroupId(long groupId) throws SystemException {
1413        Object[] finderArgs = new Object[] { new Long(groupId) };
1414
1415        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1416                finderArgs, this);
1417
1418        if (count == null) {
1419            Session session = null;
1420
1421            try {
1422                session = openSession();
1423
1424                StringBuilder query = new StringBuilder();
1425
1426                query.append("SELECT COUNT(shoppingOrder) ");
1427                query.append("FROM ShoppingOrder shoppingOrder WHERE ");
1428
1429                query.append("shoppingOrder.groupId = ?");
1430
1431                query.append(" ");
1432
1433                Query q = session.createQuery(query.toString());
1434
1435                QueryPos qPos = QueryPos.getInstance(q);
1436
1437                qPos.add(groupId);
1438
1439                count = (Long)q.uniqueResult();
1440            }
1441            catch (Exception e) {
1442                throw processException(e);
1443            }
1444            finally {
1445                if (count == null) {
1446                    count = Long.valueOf(0);
1447                }
1448
1449                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1450                    finderArgs, count);
1451
1452                closeSession(session);
1453            }
1454        }
1455
1456        return count.intValue();
1457    }
1458
1459    public int countByNumber(String number) throws SystemException {
1460        Object[] finderArgs = new Object[] { number };
1461
1462        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_NUMBER,
1463                finderArgs, this);
1464
1465        if (count == null) {
1466            Session session = null;
1467
1468            try {
1469                session = openSession();
1470
1471                StringBuilder query = new StringBuilder();
1472
1473                query.append("SELECT COUNT(shoppingOrder) ");
1474                query.append("FROM ShoppingOrder shoppingOrder WHERE ");
1475
1476                if (number == null) {
1477                    query.append("shoppingOrder.number IS NULL");
1478                }
1479                else {
1480                    query.append("shoppingOrder.number = ?");
1481                }
1482
1483                query.append(" ");
1484
1485                Query q = session.createQuery(query.toString());
1486
1487                QueryPos qPos = QueryPos.getInstance(q);
1488
1489                if (number != null) {
1490                    qPos.add(number);
1491                }
1492
1493                count = (Long)q.uniqueResult();
1494            }
1495            catch (Exception e) {
1496                throw processException(e);
1497            }
1498            finally {
1499                if (count == null) {
1500                    count = Long.valueOf(0);
1501                }
1502
1503                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_NUMBER,
1504                    finderArgs, count);
1505
1506                closeSession(session);
1507            }
1508        }
1509
1510        return count.intValue();
1511    }
1512
1513    public int countByPPTxnId(String ppTxnId) throws SystemException {
1514        Object[] finderArgs = new Object[] { ppTxnId };
1515
1516        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_PPTXNID,
1517                finderArgs, this);
1518
1519        if (count == null) {
1520            Session session = null;
1521
1522            try {
1523                session = openSession();
1524
1525                StringBuilder query = new StringBuilder();
1526
1527                query.append("SELECT COUNT(shoppingOrder) ");
1528                query.append("FROM ShoppingOrder shoppingOrder WHERE ");
1529
1530                if (ppTxnId == null) {
1531                    query.append("shoppingOrder.ppTxnId IS NULL");
1532                }
1533                else {
1534                    query.append("shoppingOrder.ppTxnId = ?");
1535                }
1536
1537                query.append(" ");
1538
1539                Query q = session.createQuery(query.toString());
1540
1541                QueryPos qPos = QueryPos.getInstance(q);
1542
1543                if (ppTxnId != null) {
1544                    qPos.add(ppTxnId);
1545                }
1546
1547                count = (Long)q.uniqueResult();
1548            }
1549            catch (Exception e) {
1550                throw processException(e);
1551            }
1552            finally {
1553                if (count == null) {
1554                    count = Long.valueOf(0);
1555                }
1556
1557                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_PPTXNID,
1558                    finderArgs, count);
1559
1560                closeSession(session);
1561            }
1562        }
1563
1564        return count.intValue();
1565    }
1566
1567    public int countByG_U_PPPS(long groupId, long userId, String ppPaymentStatus)
1568        throws SystemException {
1569        Object[] finderArgs = new Object[] {
1570                new Long(groupId), new Long(userId),
1571                
1572                ppPaymentStatus
1573            };
1574
1575        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_PPPS,
1576                finderArgs, this);
1577
1578        if (count == null) {
1579            Session session = null;
1580
1581            try {
1582                session = openSession();
1583
1584                StringBuilder query = new StringBuilder();
1585
1586                query.append("SELECT COUNT(shoppingOrder) ");
1587                query.append("FROM ShoppingOrder shoppingOrder WHERE ");
1588
1589                query.append("shoppingOrder.groupId = ?");
1590
1591                query.append(" AND ");
1592
1593                query.append("shoppingOrder.userId = ?");
1594
1595                query.append(" AND ");
1596
1597                if (ppPaymentStatus == null) {
1598                    query.append("shoppingOrder.ppPaymentStatus IS NULL");
1599                }
1600                else {
1601                    query.append("shoppingOrder.ppPaymentStatus = ?");
1602                }
1603
1604                query.append(" ");
1605
1606                Query q = session.createQuery(query.toString());
1607
1608                QueryPos qPos = QueryPos.getInstance(q);
1609
1610                qPos.add(groupId);
1611
1612                qPos.add(userId);
1613
1614                if (ppPaymentStatus != null) {
1615                    qPos.add(ppPaymentStatus);
1616                }
1617
1618                count = (Long)q.uniqueResult();
1619            }
1620            catch (Exception e) {
1621                throw processException(e);
1622            }
1623            finally {
1624                if (count == null) {
1625                    count = Long.valueOf(0);
1626                }
1627
1628                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_PPPS,
1629                    finderArgs, count);
1630
1631                closeSession(session);
1632            }
1633        }
1634
1635        return count.intValue();
1636    }
1637
1638    public int countAll() throws SystemException {
1639        Object[] finderArgs = new Object[0];
1640
1641        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1642                finderArgs, this);
1643
1644        if (count == null) {
1645            Session session = null;
1646
1647            try {
1648                session = openSession();
1649
1650                Query q = session.createQuery(
1651                        "SELECT COUNT(shoppingOrder) FROM ShoppingOrder shoppingOrder");
1652
1653                count = (Long)q.uniqueResult();
1654            }
1655            catch (Exception e) {
1656                throw processException(e);
1657            }
1658            finally {
1659                if (count == null) {
1660                    count = Long.valueOf(0);
1661                }
1662
1663                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1664                    count);
1665
1666                closeSession(session);
1667            }
1668        }
1669
1670        return count.intValue();
1671    }
1672
1673    public void afterPropertiesSet() {
1674        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1675                    com.liferay.portal.util.PropsUtil.get(
1676                        "value.object.listener.com.liferay.portlet.shopping.model.ShoppingOrder")));
1677
1678        if (listenerClassNames.length > 0) {
1679            try {
1680                List<ModelListener<ShoppingOrder>> listenersList = new ArrayList<ModelListener<ShoppingOrder>>();
1681
1682                for (String listenerClassName : listenerClassNames) {
1683                    listenersList.add((ModelListener<ShoppingOrder>)Class.forName(
1684                            listenerClassName).newInstance());
1685                }
1686
1687                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1688            }
1689            catch (Exception e) {
1690                _log.error(e);
1691            }
1692        }
1693    }
1694
1695    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingCartPersistence.impl")
1696    protected com.liferay.portlet.shopping.service.persistence.ShoppingCartPersistence shoppingCartPersistence;
1697    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingCategoryPersistence.impl")
1698    protected com.liferay.portlet.shopping.service.persistence.ShoppingCategoryPersistence shoppingCategoryPersistence;
1699    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingCouponPersistence.impl")
1700    protected com.liferay.portlet.shopping.service.persistence.ShoppingCouponPersistence shoppingCouponPersistence;
1701    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingItemPersistence.impl")
1702    protected com.liferay.portlet.shopping.service.persistence.ShoppingItemPersistence shoppingItemPersistence;
1703    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingItemFieldPersistence.impl")
1704    protected com.liferay.portlet.shopping.service.persistence.ShoppingItemFieldPersistence shoppingItemFieldPersistence;
1705    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingItemPricePersistence.impl")
1706    protected com.liferay.portlet.shopping.service.persistence.ShoppingItemPricePersistence shoppingItemPricePersistence;
1707    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingOrderPersistence.impl")
1708    protected com.liferay.portlet.shopping.service.persistence.ShoppingOrderPersistence shoppingOrderPersistence;
1709    @BeanReference(name = "com.liferay.portlet.shopping.service.persistence.ShoppingOrderItemPersistence.impl")
1710    protected com.liferay.portlet.shopping.service.persistence.ShoppingOrderItemPersistence shoppingOrderItemPersistence;
1711    @BeanReference(name = "com.liferay.portal.service.persistence.CompanyPersistence.impl")
1712    protected com.liferay.portal.service.persistence.CompanyPersistence companyPersistence;
1713    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
1714    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1715    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence.impl")
1716    protected com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence mbMessagePersistence;
1717    private static Log _log = LogFactoryUtil.getLog(ShoppingOrderPersistenceImpl.class);
1718}