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