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