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