1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.shopping.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.Session;
27  import com.liferay.portal.kernel.exception.SystemException;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.OrderByComparator;
32  import com.liferay.portal.kernel.util.StringBundler;
33  import com.liferay.portal.kernel.util.StringPool;
34  import com.liferay.portal.kernel.util.StringUtil;
35  import com.liferay.portal.model.ModelListener;
36  import com.liferay.portal.service.persistence.BatchSessionUtil;
37  import com.liferay.portal.service.persistence.ResourcePersistence;
38  import com.liferay.portal.service.persistence.UserPersistence;
39  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
40  
41  import com.liferay.portlet.shopping.NoSuchCartException;
42  import com.liferay.portlet.shopping.model.ShoppingCart;
43  import com.liferay.portlet.shopping.model.impl.ShoppingCartImpl;
44  import com.liferay.portlet.shopping.model.impl.ShoppingCartModelImpl;
45  
46  import java.io.Serializable;
47  
48  import java.util.ArrayList;
49  import java.util.Collections;
50  import java.util.List;
51  
52  /**
53   * <a href="ShoppingCartPersistenceImpl.java.html"><b><i>View Source</i></b></a>
54   *
55   * <p>
56   * ServiceBuilder generated this class. Modifications in this class will be
57   * overwritten the next time is generated.
58   * </p>
59   *
60   * @author    Brian Wing Shun Chan
61   * @see       ShoppingCartPersistence
62   * @see       ShoppingCartUtil
63   * @generated
64   */
65  public class ShoppingCartPersistenceImpl extends BasePersistenceImpl<ShoppingCart>
66      implements ShoppingCartPersistence {
67      public static final String FINDER_CLASS_NAME_ENTITY = ShoppingCartImpl.class.getName();
68      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
69          ".List";
70      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
71              ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
72              "findByGroupId", new String[] { Long.class.getName() });
73      public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
74              ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
75              "findByGroupId",
76              new String[] {
77                  Long.class.getName(),
78                  
79              "java.lang.Integer", "java.lang.Integer",
80                  "com.liferay.portal.kernel.util.OrderByComparator"
81              });
82      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
83              ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
84              "countByGroupId", new String[] { Long.class.getName() });
85      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
86              ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
87              "findByUserId", new String[] { Long.class.getName() });
88      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
89              ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
90              "findByUserId",
91              new String[] {
92                  Long.class.getName(),
93                  
94              "java.lang.Integer", "java.lang.Integer",
95                  "com.liferay.portal.kernel.util.OrderByComparator"
96              });
97      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
98              ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
99              "countByUserId", new String[] { Long.class.getName() });
100     public static final FinderPath FINDER_PATH_FETCH_BY_G_U = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
101             ShoppingCartModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_ENTITY, "fetchByG_U",
103             new String[] { Long.class.getName(), Long.class.getName() });
104     public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
105             ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
106             "countByG_U",
107             new String[] { Long.class.getName(), Long.class.getName() });
108     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
109             ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
110             "findAll", new String[0]);
111     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
112             ShoppingCartModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
113             "countAll", new String[0]);
114 
115     public void cacheResult(ShoppingCart shoppingCart) {
116         EntityCacheUtil.putResult(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
117             ShoppingCartImpl.class, shoppingCart.getPrimaryKey(), shoppingCart);
118 
119         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
120             new Object[] {
121                 new Long(shoppingCart.getGroupId()),
122                 new Long(shoppingCart.getUserId())
123             }, shoppingCart);
124     }
125 
126     public void cacheResult(List<ShoppingCart> shoppingCarts) {
127         for (ShoppingCart shoppingCart : shoppingCarts) {
128             if (EntityCacheUtil.getResult(
129                         ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
130                         ShoppingCartImpl.class, shoppingCart.getPrimaryKey(),
131                         this) == null) {
132                 cacheResult(shoppingCart);
133             }
134         }
135     }
136 
137     public void clearCache() {
138         CacheRegistry.clear(ShoppingCartImpl.class.getName());
139         EntityCacheUtil.clearCache(ShoppingCartImpl.class.getName());
140         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
141         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
142     }
143 
144     public ShoppingCart create(long cartId) {
145         ShoppingCart shoppingCart = new ShoppingCartImpl();
146 
147         shoppingCart.setNew(true);
148         shoppingCart.setPrimaryKey(cartId);
149 
150         return shoppingCart;
151     }
152 
153     public ShoppingCart remove(Serializable primaryKey)
154         throws NoSuchModelException, SystemException {
155         return remove(((Long)primaryKey).longValue());
156     }
157 
158     public ShoppingCart remove(long cartId)
159         throws NoSuchCartException, SystemException {
160         Session session = null;
161 
162         try {
163             session = openSession();
164 
165             ShoppingCart shoppingCart = (ShoppingCart)session.get(ShoppingCartImpl.class,
166                     new Long(cartId));
167 
168             if (shoppingCart == null) {
169                 if (_log.isWarnEnabled()) {
170                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + cartId);
171                 }
172 
173                 throw new NoSuchCartException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
174                     cartId);
175             }
176 
177             return remove(shoppingCart);
178         }
179         catch (NoSuchCartException nsee) {
180             throw nsee;
181         }
182         catch (Exception e) {
183             throw processException(e);
184         }
185         finally {
186             closeSession(session);
187         }
188     }
189 
190     public ShoppingCart remove(ShoppingCart shoppingCart)
191         throws SystemException {
192         for (ModelListener<ShoppingCart> listener : listeners) {
193             listener.onBeforeRemove(shoppingCart);
194         }
195 
196         shoppingCart = removeImpl(shoppingCart);
197 
198         for (ModelListener<ShoppingCart> listener : listeners) {
199             listener.onAfterRemove(shoppingCart);
200         }
201 
202         return shoppingCart;
203     }
204 
205     protected ShoppingCart removeImpl(ShoppingCart shoppingCart)
206         throws SystemException {
207         shoppingCart = toUnwrappedModel(shoppingCart);
208 
209         Session session = null;
210 
211         try {
212             session = openSession();
213 
214             if (shoppingCart.isCachedModel() || BatchSessionUtil.isEnabled()) {
215                 Object staleObject = session.get(ShoppingCartImpl.class,
216                         shoppingCart.getPrimaryKeyObj());
217 
218                 if (staleObject != null) {
219                     session.evict(staleObject);
220                 }
221             }
222 
223             session.delete(shoppingCart);
224 
225             session.flush();
226         }
227         catch (Exception e) {
228             throw processException(e);
229         }
230         finally {
231             closeSession(session);
232         }
233 
234         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
235 
236         ShoppingCartModelImpl shoppingCartModelImpl = (ShoppingCartModelImpl)shoppingCart;
237 
238         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_U,
239             new Object[] {
240                 new Long(shoppingCartModelImpl.getOriginalGroupId()),
241                 new Long(shoppingCartModelImpl.getOriginalUserId())
242             });
243 
244         EntityCacheUtil.removeResult(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
245             ShoppingCartImpl.class, shoppingCart.getPrimaryKey());
246 
247         return shoppingCart;
248     }
249 
250     public ShoppingCart updateImpl(
251         com.liferay.portlet.shopping.model.ShoppingCart shoppingCart,
252         boolean merge) throws SystemException {
253         shoppingCart = toUnwrappedModel(shoppingCart);
254 
255         boolean isNew = shoppingCart.isNew();
256 
257         ShoppingCartModelImpl shoppingCartModelImpl = (ShoppingCartModelImpl)shoppingCart;
258 
259         Session session = null;
260 
261         try {
262             session = openSession();
263 
264             BatchSessionUtil.update(session, shoppingCart, merge);
265 
266             shoppingCart.setNew(false);
267         }
268         catch (Exception e) {
269             throw processException(e);
270         }
271         finally {
272             closeSession(session);
273         }
274 
275         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
276 
277         EntityCacheUtil.putResult(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
278             ShoppingCartImpl.class, shoppingCart.getPrimaryKey(), shoppingCart);
279 
280         if (!isNew &&
281                 ((shoppingCart.getGroupId() != shoppingCartModelImpl.getOriginalGroupId()) ||
282                 (shoppingCart.getUserId() != shoppingCartModelImpl.getOriginalUserId()))) {
283             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_U,
284                 new Object[] {
285                     new Long(shoppingCartModelImpl.getOriginalGroupId()),
286                     new Long(shoppingCartModelImpl.getOriginalUserId())
287                 });
288         }
289 
290         if (isNew ||
291                 ((shoppingCart.getGroupId() != shoppingCartModelImpl.getOriginalGroupId()) ||
292                 (shoppingCart.getUserId() != shoppingCartModelImpl.getOriginalUserId()))) {
293             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
294                 new Object[] {
295                     new Long(shoppingCart.getGroupId()),
296                     new Long(shoppingCart.getUserId())
297                 }, shoppingCart);
298         }
299 
300         return shoppingCart;
301     }
302 
303     protected ShoppingCart toUnwrappedModel(ShoppingCart shoppingCart) {
304         if (shoppingCart instanceof ShoppingCartImpl) {
305             return shoppingCart;
306         }
307 
308         ShoppingCartImpl shoppingCartImpl = new ShoppingCartImpl();
309 
310         shoppingCartImpl.setNew(shoppingCart.isNew());
311         shoppingCartImpl.setPrimaryKey(shoppingCart.getPrimaryKey());
312 
313         shoppingCartImpl.setCartId(shoppingCart.getCartId());
314         shoppingCartImpl.setGroupId(shoppingCart.getGroupId());
315         shoppingCartImpl.setCompanyId(shoppingCart.getCompanyId());
316         shoppingCartImpl.setUserId(shoppingCart.getUserId());
317         shoppingCartImpl.setUserName(shoppingCart.getUserName());
318         shoppingCartImpl.setCreateDate(shoppingCart.getCreateDate());
319         shoppingCartImpl.setModifiedDate(shoppingCart.getModifiedDate());
320         shoppingCartImpl.setItemIds(shoppingCart.getItemIds());
321         shoppingCartImpl.setCouponCodes(shoppingCart.getCouponCodes());
322         shoppingCartImpl.setAltShipping(shoppingCart.getAltShipping());
323         shoppingCartImpl.setInsure(shoppingCart.isInsure());
324 
325         return shoppingCartImpl;
326     }
327 
328     public ShoppingCart findByPrimaryKey(Serializable primaryKey)
329         throws NoSuchModelException, SystemException {
330         return findByPrimaryKey(((Long)primaryKey).longValue());
331     }
332 
333     public ShoppingCart findByPrimaryKey(long cartId)
334         throws NoSuchCartException, SystemException {
335         ShoppingCart shoppingCart = fetchByPrimaryKey(cartId);
336 
337         if (shoppingCart == null) {
338             if (_log.isWarnEnabled()) {
339                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + cartId);
340             }
341 
342             throw new NoSuchCartException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
343                 cartId);
344         }
345 
346         return shoppingCart;
347     }
348 
349     public ShoppingCart fetchByPrimaryKey(Serializable primaryKey)
350         throws SystemException {
351         return fetchByPrimaryKey(((Long)primaryKey).longValue());
352     }
353 
354     public ShoppingCart fetchByPrimaryKey(long cartId)
355         throws SystemException {
356         ShoppingCart shoppingCart = (ShoppingCart)EntityCacheUtil.getResult(ShoppingCartModelImpl.ENTITY_CACHE_ENABLED,
357                 ShoppingCartImpl.class, cartId, this);
358 
359         if (shoppingCart == null) {
360             Session session = null;
361 
362             try {
363                 session = openSession();
364 
365                 shoppingCart = (ShoppingCart)session.get(ShoppingCartImpl.class,
366                         new Long(cartId));
367             }
368             catch (Exception e) {
369                 throw processException(e);
370             }
371             finally {
372                 if (shoppingCart != null) {
373                     cacheResult(shoppingCart);
374                 }
375 
376                 closeSession(session);
377             }
378         }
379 
380         return shoppingCart;
381     }
382 
383     public List<ShoppingCart> findByGroupId(long groupId)
384         throws SystemException {
385         Object[] finderArgs = new Object[] { new Long(groupId) };
386 
387         List<ShoppingCart> list = (List<ShoppingCart>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
388                 finderArgs, this);
389 
390         if (list == null) {
391             Session session = null;
392 
393             try {
394                 session = openSession();
395 
396                 StringBundler query = new StringBundler(2);
397 
398                 query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
399 
400                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
401 
402                 String sql = query.toString();
403 
404                 Query q = session.createQuery(sql);
405 
406                 QueryPos qPos = QueryPos.getInstance(q);
407 
408                 qPos.add(groupId);
409 
410                 list = q.list();
411             }
412             catch (Exception e) {
413                 throw processException(e);
414             }
415             finally {
416                 if (list == null) {
417                     list = new ArrayList<ShoppingCart>();
418                 }
419 
420                 cacheResult(list);
421 
422                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
423                     finderArgs, list);
424 
425                 closeSession(session);
426             }
427         }
428 
429         return list;
430     }
431 
432     public List<ShoppingCart> findByGroupId(long groupId, int start, int end)
433         throws SystemException {
434         return findByGroupId(groupId, start, end, null);
435     }
436 
437     public List<ShoppingCart> findByGroupId(long groupId, int start, int end,
438         OrderByComparator orderByComparator) throws SystemException {
439         Object[] finderArgs = new Object[] {
440                 new Long(groupId),
441                 
442                 String.valueOf(start), String.valueOf(end),
443                 String.valueOf(orderByComparator)
444             };
445 
446         List<ShoppingCart> list = (List<ShoppingCart>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
447                 finderArgs, this);
448 
449         if (list == null) {
450             Session session = null;
451 
452             try {
453                 session = openSession();
454 
455                 StringBundler query = null;
456 
457                 if (orderByComparator != null) {
458                     query = new StringBundler(3 +
459                             (orderByComparator.getOrderByFields().length * 3));
460                 }
461                 else {
462                     query = new StringBundler(2);
463                 }
464 
465                 query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
466 
467                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
468 
469                 if (orderByComparator != null) {
470                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
471                         orderByComparator);
472                 }
473 
474                 String sql = query.toString();
475 
476                 Query q = session.createQuery(sql);
477 
478                 QueryPos qPos = QueryPos.getInstance(q);
479 
480                 qPos.add(groupId);
481 
482                 list = (List<ShoppingCart>)QueryUtil.list(q, getDialect(),
483                         start, end);
484             }
485             catch (Exception e) {
486                 throw processException(e);
487             }
488             finally {
489                 if (list == null) {
490                     list = new ArrayList<ShoppingCart>();
491                 }
492 
493                 cacheResult(list);
494 
495                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
496                     finderArgs, list);
497 
498                 closeSession(session);
499             }
500         }
501 
502         return list;
503     }
504 
505     public ShoppingCart findByGroupId_First(long groupId,
506         OrderByComparator orderByComparator)
507         throws NoSuchCartException, SystemException {
508         List<ShoppingCart> list = findByGroupId(groupId, 0, 1, orderByComparator);
509 
510         if (list.isEmpty()) {
511             StringBundler msg = new StringBundler(4);
512 
513             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
514 
515             msg.append("groupId=");
516             msg.append(groupId);
517 
518             msg.append(StringPool.CLOSE_CURLY_BRACE);
519 
520             throw new NoSuchCartException(msg.toString());
521         }
522         else {
523             return list.get(0);
524         }
525     }
526 
527     public ShoppingCart findByGroupId_Last(long groupId,
528         OrderByComparator orderByComparator)
529         throws NoSuchCartException, SystemException {
530         int count = countByGroupId(groupId);
531 
532         List<ShoppingCart> list = findByGroupId(groupId, count - 1, count,
533                 orderByComparator);
534 
535         if (list.isEmpty()) {
536             StringBundler msg = new StringBundler(4);
537 
538             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
539 
540             msg.append("groupId=");
541             msg.append(groupId);
542 
543             msg.append(StringPool.CLOSE_CURLY_BRACE);
544 
545             throw new NoSuchCartException(msg.toString());
546         }
547         else {
548             return list.get(0);
549         }
550     }
551 
552     public ShoppingCart[] findByGroupId_PrevAndNext(long cartId, long groupId,
553         OrderByComparator orderByComparator)
554         throws NoSuchCartException, SystemException {
555         ShoppingCart shoppingCart = findByPrimaryKey(cartId);
556 
557         int count = countByGroupId(groupId);
558 
559         Session session = null;
560 
561         try {
562             session = openSession();
563 
564             StringBundler query = null;
565 
566             if (orderByComparator != null) {
567                 query = new StringBundler(3 +
568                         (orderByComparator.getOrderByFields().length * 3));
569             }
570             else {
571                 query = new StringBundler(2);
572             }
573 
574             query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
575 
576             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
577 
578             if (orderByComparator != null) {
579                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
580                     orderByComparator);
581             }
582 
583             String sql = query.toString();
584 
585             Query q = session.createQuery(sql);
586 
587             QueryPos qPos = QueryPos.getInstance(q);
588 
589             qPos.add(groupId);
590 
591             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
592                     orderByComparator, shoppingCart);
593 
594             ShoppingCart[] array = new ShoppingCartImpl[3];
595 
596             array[0] = (ShoppingCart)objArray[0];
597             array[1] = (ShoppingCart)objArray[1];
598             array[2] = (ShoppingCart)objArray[2];
599 
600             return array;
601         }
602         catch (Exception e) {
603             throw processException(e);
604         }
605         finally {
606             closeSession(session);
607         }
608     }
609 
610     public List<ShoppingCart> findByUserId(long userId)
611         throws SystemException {
612         Object[] finderArgs = new Object[] { new Long(userId) };
613 
614         List<ShoppingCart> list = (List<ShoppingCart>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
615                 finderArgs, this);
616 
617         if (list == null) {
618             Session session = null;
619 
620             try {
621                 session = openSession();
622 
623                 StringBundler query = new StringBundler(2);
624 
625                 query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
626 
627                 query.append(_FINDER_COLUMN_USERID_USERID_2);
628 
629                 String sql = query.toString();
630 
631                 Query q = session.createQuery(sql);
632 
633                 QueryPos qPos = QueryPos.getInstance(q);
634 
635                 qPos.add(userId);
636 
637                 list = q.list();
638             }
639             catch (Exception e) {
640                 throw processException(e);
641             }
642             finally {
643                 if (list == null) {
644                     list = new ArrayList<ShoppingCart>();
645                 }
646 
647                 cacheResult(list);
648 
649                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
650                     finderArgs, list);
651 
652                 closeSession(session);
653             }
654         }
655 
656         return list;
657     }
658 
659     public List<ShoppingCart> findByUserId(long userId, int start, int end)
660         throws SystemException {
661         return findByUserId(userId, start, end, null);
662     }
663 
664     public List<ShoppingCart> findByUserId(long userId, int start, int end,
665         OrderByComparator orderByComparator) throws SystemException {
666         Object[] finderArgs = new Object[] {
667                 new Long(userId),
668                 
669                 String.valueOf(start), String.valueOf(end),
670                 String.valueOf(orderByComparator)
671             };
672 
673         List<ShoppingCart> list = (List<ShoppingCart>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
674                 finderArgs, this);
675 
676         if (list == null) {
677             Session session = null;
678 
679             try {
680                 session = openSession();
681 
682                 StringBundler query = null;
683 
684                 if (orderByComparator != null) {
685                     query = new StringBundler(3 +
686                             (orderByComparator.getOrderByFields().length * 3));
687                 }
688                 else {
689                     query = new StringBundler(2);
690                 }
691 
692                 query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
693 
694                 query.append(_FINDER_COLUMN_USERID_USERID_2);
695 
696                 if (orderByComparator != null) {
697                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
698                         orderByComparator);
699                 }
700 
701                 String sql = query.toString();
702 
703                 Query q = session.createQuery(sql);
704 
705                 QueryPos qPos = QueryPos.getInstance(q);
706 
707                 qPos.add(userId);
708 
709                 list = (List<ShoppingCart>)QueryUtil.list(q, getDialect(),
710                         start, end);
711             }
712             catch (Exception e) {
713                 throw processException(e);
714             }
715             finally {
716                 if (list == null) {
717                     list = new ArrayList<ShoppingCart>();
718                 }
719 
720                 cacheResult(list);
721 
722                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
723                     finderArgs, list);
724 
725                 closeSession(session);
726             }
727         }
728 
729         return list;
730     }
731 
732     public ShoppingCart findByUserId_First(long userId,
733         OrderByComparator orderByComparator)
734         throws NoSuchCartException, SystemException {
735         List<ShoppingCart> list = findByUserId(userId, 0, 1, orderByComparator);
736 
737         if (list.isEmpty()) {
738             StringBundler msg = new StringBundler(4);
739 
740             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
741 
742             msg.append("userId=");
743             msg.append(userId);
744 
745             msg.append(StringPool.CLOSE_CURLY_BRACE);
746 
747             throw new NoSuchCartException(msg.toString());
748         }
749         else {
750             return list.get(0);
751         }
752     }
753 
754     public ShoppingCart findByUserId_Last(long userId,
755         OrderByComparator orderByComparator)
756         throws NoSuchCartException, SystemException {
757         int count = countByUserId(userId);
758 
759         List<ShoppingCart> list = findByUserId(userId, count - 1, count,
760                 orderByComparator);
761 
762         if (list.isEmpty()) {
763             StringBundler msg = new StringBundler(4);
764 
765             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
766 
767             msg.append("userId=");
768             msg.append(userId);
769 
770             msg.append(StringPool.CLOSE_CURLY_BRACE);
771 
772             throw new NoSuchCartException(msg.toString());
773         }
774         else {
775             return list.get(0);
776         }
777     }
778 
779     public ShoppingCart[] findByUserId_PrevAndNext(long cartId, long userId,
780         OrderByComparator orderByComparator)
781         throws NoSuchCartException, SystemException {
782         ShoppingCart shoppingCart = findByPrimaryKey(cartId);
783 
784         int count = countByUserId(userId);
785 
786         Session session = null;
787 
788         try {
789             session = openSession();
790 
791             StringBundler query = null;
792 
793             if (orderByComparator != null) {
794                 query = new StringBundler(3 +
795                         (orderByComparator.getOrderByFields().length * 3));
796             }
797             else {
798                 query = new StringBundler(2);
799             }
800 
801             query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
802 
803             query.append(_FINDER_COLUMN_USERID_USERID_2);
804 
805             if (orderByComparator != null) {
806                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
807                     orderByComparator);
808             }
809 
810             String sql = query.toString();
811 
812             Query q = session.createQuery(sql);
813 
814             QueryPos qPos = QueryPos.getInstance(q);
815 
816             qPos.add(userId);
817 
818             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
819                     orderByComparator, shoppingCart);
820 
821             ShoppingCart[] array = new ShoppingCartImpl[3];
822 
823             array[0] = (ShoppingCart)objArray[0];
824             array[1] = (ShoppingCart)objArray[1];
825             array[2] = (ShoppingCart)objArray[2];
826 
827             return array;
828         }
829         catch (Exception e) {
830             throw processException(e);
831         }
832         finally {
833             closeSession(session);
834         }
835     }
836 
837     public ShoppingCart findByG_U(long groupId, long userId)
838         throws NoSuchCartException, SystemException {
839         ShoppingCart shoppingCart = fetchByG_U(groupId, userId);
840 
841         if (shoppingCart == null) {
842             StringBundler msg = new StringBundler(6);
843 
844             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
845 
846             msg.append("groupId=");
847             msg.append(groupId);
848 
849             msg.append(", userId=");
850             msg.append(userId);
851 
852             msg.append(StringPool.CLOSE_CURLY_BRACE);
853 
854             if (_log.isWarnEnabled()) {
855                 _log.warn(msg.toString());
856             }
857 
858             throw new NoSuchCartException(msg.toString());
859         }
860 
861         return shoppingCart;
862     }
863 
864     public ShoppingCart fetchByG_U(long groupId, long userId)
865         throws SystemException {
866         return fetchByG_U(groupId, userId, true);
867     }
868 
869     public ShoppingCart fetchByG_U(long groupId, long userId,
870         boolean retrieveFromCache) throws SystemException {
871         Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
872 
873         Object result = null;
874 
875         if (retrieveFromCache) {
876             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_U,
877                     finderArgs, this);
878         }
879 
880         if (result == null) {
881             Session session = null;
882 
883             try {
884                 session = openSession();
885 
886                 StringBundler query = new StringBundler(3);
887 
888                 query.append(_SQL_SELECT_SHOPPINGCART_WHERE);
889 
890                 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
891 
892                 query.append(_FINDER_COLUMN_G_U_USERID_2);
893 
894                 String sql = query.toString();
895 
896                 Query q = session.createQuery(sql);
897 
898                 QueryPos qPos = QueryPos.getInstance(q);
899 
900                 qPos.add(groupId);
901 
902                 qPos.add(userId);
903 
904                 List<ShoppingCart> list = q.list();
905 
906                 result = list;
907 
908                 ShoppingCart shoppingCart = null;
909 
910                 if (list.isEmpty()) {
911                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
912                         finderArgs, list);
913                 }
914                 else {
915                     shoppingCart = list.get(0);
916 
917                     cacheResult(shoppingCart);
918 
919                     if ((shoppingCart.getGroupId() != groupId) ||
920                             (shoppingCart.getUserId() != userId)) {
921                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
922                             finderArgs, shoppingCart);
923                     }
924                 }
925 
926                 return shoppingCart;
927             }
928             catch (Exception e) {
929                 throw processException(e);
930             }
931             finally {
932                 if (result == null) {
933                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
934                         finderArgs, new ArrayList<ShoppingCart>());
935                 }
936 
937                 closeSession(session);
938             }
939         }
940         else {
941             if (result instanceof List<?>) {
942                 return null;
943             }
944             else {
945                 return (ShoppingCart)result;
946             }
947         }
948     }
949 
950     public List<ShoppingCart> findAll() throws SystemException {
951         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
952     }
953 
954     public List<ShoppingCart> findAll(int start, int end)
955         throws SystemException {
956         return findAll(start, end, null);
957     }
958 
959     public List<ShoppingCart> findAll(int start, int end,
960         OrderByComparator orderByComparator) throws SystemException {
961         Object[] finderArgs = new Object[] {
962                 String.valueOf(start), String.valueOf(end),
963                 String.valueOf(orderByComparator)
964             };
965 
966         List<ShoppingCart> list = (List<ShoppingCart>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
967                 finderArgs, this);
968 
969         if (list == null) {
970             Session session = null;
971 
972             try {
973                 session = openSession();
974 
975                 StringBundler query = null;
976                 String sql = null;
977 
978                 if (orderByComparator != null) {
979                     query = new StringBundler(2 +
980                             (orderByComparator.getOrderByFields().length * 3));
981 
982                     query.append(_SQL_SELECT_SHOPPINGCART);
983 
984                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
985                         orderByComparator);
986 
987                     sql = query.toString();
988                 }
989 
990                 sql = _SQL_SELECT_SHOPPINGCART;
991 
992                 Query q = session.createQuery(sql);
993 
994                 if (orderByComparator == null) {
995                     list = (List<ShoppingCart>)QueryUtil.list(q, getDialect(),
996                             start, end, false);
997 
998                     Collections.sort(list);
999                 }
1000                else {
1001                    list = (List<ShoppingCart>)QueryUtil.list(q, getDialect(),
1002                            start, end);
1003                }
1004            }
1005            catch (Exception e) {
1006                throw processException(e);
1007            }
1008            finally {
1009                if (list == null) {
1010                    list = new ArrayList<ShoppingCart>();
1011                }
1012
1013                cacheResult(list);
1014
1015                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1016
1017                closeSession(session);
1018            }
1019        }
1020
1021        return list;
1022    }
1023
1024    public void removeByGroupId(long groupId) throws SystemException {
1025        for (ShoppingCart shoppingCart : findByGroupId(groupId)) {
1026            remove(shoppingCart);
1027        }
1028    }
1029
1030    public void removeByUserId(long userId) throws SystemException {
1031        for (ShoppingCart shoppingCart : findByUserId(userId)) {
1032            remove(shoppingCart);
1033        }
1034    }
1035
1036    public void removeByG_U(long groupId, long userId)
1037        throws NoSuchCartException, SystemException {
1038        ShoppingCart shoppingCart = findByG_U(groupId, userId);
1039
1040        remove(shoppingCart);
1041    }
1042
1043    public void removeAll() throws SystemException {
1044        for (ShoppingCart shoppingCart : findAll()) {
1045            remove(shoppingCart);
1046        }
1047    }
1048
1049    public int countByGroupId(long groupId) throws SystemException {
1050        Object[] finderArgs = new Object[] { new Long(groupId) };
1051
1052        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1053                finderArgs, this);
1054
1055        if (count == null) {
1056            Session session = null;
1057
1058            try {
1059                session = openSession();
1060
1061                StringBundler query = new StringBundler(2);
1062
1063                query.append(_SQL_COUNT_SHOPPINGCART_WHERE);
1064
1065                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1066
1067                String sql = query.toString();
1068
1069                Query q = session.createQuery(sql);
1070
1071                QueryPos qPos = QueryPos.getInstance(q);
1072
1073                qPos.add(groupId);
1074
1075                count = (Long)q.uniqueResult();
1076            }
1077            catch (Exception e) {
1078                throw processException(e);
1079            }
1080            finally {
1081                if (count == null) {
1082                    count = Long.valueOf(0);
1083                }
1084
1085                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1086                    finderArgs, count);
1087
1088                closeSession(session);
1089            }
1090        }
1091
1092        return count.intValue();
1093    }
1094
1095    public int countByUserId(long userId) throws SystemException {
1096        Object[] finderArgs = new Object[] { new Long(userId) };
1097
1098        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1099                finderArgs, this);
1100
1101        if (count == null) {
1102            Session session = null;
1103
1104            try {
1105                session = openSession();
1106
1107                StringBundler query = new StringBundler(2);
1108
1109                query.append(_SQL_COUNT_SHOPPINGCART_WHERE);
1110
1111                query.append(_FINDER_COLUMN_USERID_USERID_2);
1112
1113                String sql = query.toString();
1114
1115                Query q = session.createQuery(sql);
1116
1117                QueryPos qPos = QueryPos.getInstance(q);
1118
1119                qPos.add(userId);
1120
1121                count = (Long)q.uniqueResult();
1122            }
1123            catch (Exception e) {
1124                throw processException(e);
1125            }
1126            finally {
1127                if (count == null) {
1128                    count = Long.valueOf(0);
1129                }
1130
1131                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1132                    finderArgs, count);
1133
1134                closeSession(session);
1135            }
1136        }
1137
1138        return count.intValue();
1139    }
1140
1141    public int countByG_U(long groupId, long userId) throws SystemException {
1142        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
1143
1144        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1145                finderArgs, this);
1146
1147        if (count == null) {
1148            Session session = null;
1149
1150            try {
1151                session = openSession();
1152
1153                StringBundler query = new StringBundler(3);
1154
1155                query.append(_SQL_COUNT_SHOPPINGCART_WHERE);
1156
1157                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1158
1159                query.append(_FINDER_COLUMN_G_U_USERID_2);
1160
1161                String sql = query.toString();
1162
1163                Query q = session.createQuery(sql);
1164
1165                QueryPos qPos = QueryPos.getInstance(q);
1166
1167                qPos.add(groupId);
1168
1169                qPos.add(userId);
1170
1171                count = (Long)q.uniqueResult();
1172            }
1173            catch (Exception e) {
1174                throw processException(e);
1175            }
1176            finally {
1177                if (count == null) {
1178                    count = Long.valueOf(0);
1179                }
1180
1181                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1182                    count);
1183
1184                closeSession(session);
1185            }
1186        }
1187
1188        return count.intValue();
1189    }
1190
1191    public int countAll() throws SystemException {
1192        Object[] finderArgs = new Object[0];
1193
1194        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1195                finderArgs, this);
1196
1197        if (count == null) {
1198            Session session = null;
1199
1200            try {
1201                session = openSession();
1202
1203                Query q = session.createQuery(_SQL_COUNT_SHOPPINGCART);
1204
1205                count = (Long)q.uniqueResult();
1206            }
1207            catch (Exception e) {
1208                throw processException(e);
1209            }
1210            finally {
1211                if (count == null) {
1212                    count = Long.valueOf(0);
1213                }
1214
1215                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1216                    count);
1217
1218                closeSession(session);
1219            }
1220        }
1221
1222        return count.intValue();
1223    }
1224
1225    public void afterPropertiesSet() {
1226        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1227                    com.liferay.portal.util.PropsUtil.get(
1228                        "value.object.listener.com.liferay.portlet.shopping.model.ShoppingCart")));
1229
1230        if (listenerClassNames.length > 0) {
1231            try {
1232                List<ModelListener<ShoppingCart>> listenersList = new ArrayList<ModelListener<ShoppingCart>>();
1233
1234                for (String listenerClassName : listenerClassNames) {
1235                    listenersList.add((ModelListener<ShoppingCart>)Class.forName(
1236                            listenerClassName).newInstance());
1237                }
1238
1239                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1240            }
1241            catch (Exception e) {
1242                _log.error(e);
1243            }
1244        }
1245    }
1246
1247    @BeanReference(type = ShoppingCartPersistence.class)
1248    protected ShoppingCartPersistence shoppingCartPersistence;
1249    @BeanReference(type = ShoppingCategoryPersistence.class)
1250    protected ShoppingCategoryPersistence shoppingCategoryPersistence;
1251    @BeanReference(type = ShoppingCouponPersistence.class)
1252    protected ShoppingCouponPersistence shoppingCouponPersistence;
1253    @BeanReference(type = ShoppingItemPersistence.class)
1254    protected ShoppingItemPersistence shoppingItemPersistence;
1255    @BeanReference(type = ShoppingItemFieldPersistence.class)
1256    protected ShoppingItemFieldPersistence shoppingItemFieldPersistence;
1257    @BeanReference(type = ShoppingItemPricePersistence.class)
1258    protected ShoppingItemPricePersistence shoppingItemPricePersistence;
1259    @BeanReference(type = ShoppingOrderPersistence.class)
1260    protected ShoppingOrderPersistence shoppingOrderPersistence;
1261    @BeanReference(type = ShoppingOrderItemPersistence.class)
1262    protected ShoppingOrderItemPersistence shoppingOrderItemPersistence;
1263    @BeanReference(type = ResourcePersistence.class)
1264    protected ResourcePersistence resourcePersistence;
1265    @BeanReference(type = UserPersistence.class)
1266    protected UserPersistence userPersistence;
1267    private static final String _SQL_SELECT_SHOPPINGCART = "SELECT shoppingCart FROM ShoppingCart shoppingCart";
1268    private static final String _SQL_SELECT_SHOPPINGCART_WHERE = "SELECT shoppingCart FROM ShoppingCart shoppingCart WHERE ";
1269    private static final String _SQL_COUNT_SHOPPINGCART = "SELECT COUNT(shoppingCart) FROM ShoppingCart shoppingCart";
1270    private static final String _SQL_COUNT_SHOPPINGCART_WHERE = "SELECT COUNT(shoppingCart) FROM ShoppingCart shoppingCart WHERE ";
1271    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "shoppingCart.groupId = ?";
1272    private static final String _FINDER_COLUMN_USERID_USERID_2 = "shoppingCart.userId = ?";
1273    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "shoppingCart.groupId = ? AND ";
1274    private static final String _FINDER_COLUMN_G_U_USERID_2 = "shoppingCart.userId = ?";
1275    private static final String _ORDER_BY_ENTITY_ALIAS = "shoppingCart.";
1276    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ShoppingCart exists with the primary key ";
1277    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ShoppingCart exists with the key {";
1278    private static Log _log = LogFactoryUtil.getLog(ShoppingCartPersistenceImpl.class);
1279}