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