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