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