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