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