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