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