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