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