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.SQLQuery;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.kernel.util.Validator;
038    import com.liferay.portal.model.ModelListener;
039    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
040    import com.liferay.portal.service.persistence.BatchSessionUtil;
041    import com.liferay.portal.service.persistence.CompanyPersistence;
042    import com.liferay.portal.service.persistence.ResourcePersistence;
043    import com.liferay.portal.service.persistence.UserPersistence;
044    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
045    
046    import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
047    import com.liferay.portlet.shopping.NoSuchOrderException;
048    import com.liferay.portlet.shopping.model.ShoppingOrder;
049    import com.liferay.portlet.shopping.model.impl.ShoppingOrderImpl;
050    import com.liferay.portlet.shopping.model.impl.ShoppingOrderModelImpl;
051    
052    import java.io.Serializable;
053    
054    import java.util.ArrayList;
055    import java.util.Collections;
056    import java.util.List;
057    
058    /**
059     * @author    Brian Wing Shun Chan
060     * @see       ShoppingOrderPersistence
061     * @see       ShoppingOrderUtil
062     * @generated
063     */
064    public class ShoppingOrderPersistenceImpl extends BasePersistenceImpl<ShoppingOrder>
065            implements ShoppingOrderPersistence {
066            public static final String FINDER_CLASS_NAME_ENTITY = ShoppingOrderImpl.class.getName();
067            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
068                    ".List";
069            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
070                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
071                            FINDER_CLASS_NAME_LIST, "findByGroupId",
072                            new String[] {
073                                    Long.class.getName(),
074                                    
075                            "java.lang.Integer", "java.lang.Integer",
076                                    "com.liferay.portal.kernel.util.OrderByComparator"
077                            });
078            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
079                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
080                            FINDER_CLASS_NAME_LIST, "countByGroupId",
081                            new String[] { Long.class.getName() });
082            public static final FinderPath FINDER_PATH_FETCH_BY_NUMBER = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
083                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
084                            FINDER_CLASS_NAME_ENTITY, "fetchByNumber",
085                            new String[] { String.class.getName() });
086            public static final FinderPath FINDER_PATH_COUNT_BY_NUMBER = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
087                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
088                            FINDER_CLASS_NAME_LIST, "countByNumber",
089                            new String[] { String.class.getName() });
090            public static final FinderPath FINDER_PATH_FETCH_BY_PPTXNID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
091                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
092                            FINDER_CLASS_NAME_ENTITY, "fetchByPPTxnId",
093                            new String[] { String.class.getName() });
094            public static final FinderPath FINDER_PATH_COUNT_BY_PPTXNID = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
095                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
096                            FINDER_CLASS_NAME_LIST, "countByPPTxnId",
097                            new String[] { String.class.getName() });
098            public static final FinderPath FINDER_PATH_FIND_BY_G_U_PPPS = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
099                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
100                            FINDER_CLASS_NAME_LIST, "findByG_U_PPPS",
101                            new String[] {
102                                    Long.class.getName(), Long.class.getName(),
103                                    String.class.getName(),
104                                    
105                            "java.lang.Integer", "java.lang.Integer",
106                                    "com.liferay.portal.kernel.util.OrderByComparator"
107                            });
108            public static final FinderPath FINDER_PATH_COUNT_BY_G_U_PPPS = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
109                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
110                            FINDER_CLASS_NAME_LIST, "countByG_U_PPPS",
111                            new String[] {
112                                    Long.class.getName(), Long.class.getName(),
113                                    String.class.getName()
114                            });
115            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
116                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
117                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
118            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
119                            ShoppingOrderModelImpl.FINDER_CACHE_ENABLED,
120                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
121    
122            public void cacheResult(ShoppingOrder shoppingOrder) {
123                    EntityCacheUtil.putResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
124                            ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey(),
125                            shoppingOrder);
126    
127                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
128                            new Object[] { shoppingOrder.getNumber() }, shoppingOrder);
129    
130                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
131                            new Object[] { shoppingOrder.getPpTxnId() }, shoppingOrder);
132            }
133    
134            public void cacheResult(List<ShoppingOrder> shoppingOrders) {
135                    for (ShoppingOrder shoppingOrder : shoppingOrders) {
136                            if (EntityCacheUtil.getResult(
137                                                    ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
138                                                    ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey(),
139                                                    this) == null) {
140                                    cacheResult(shoppingOrder);
141                            }
142                    }
143            }
144    
145            public void clearCache() {
146                    CacheRegistryUtil.clear(ShoppingOrderImpl.class.getName());
147                    EntityCacheUtil.clearCache(ShoppingOrderImpl.class.getName());
148                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
149                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
150            }
151    
152            public void clearCache(ShoppingOrder shoppingOrder) {
153                    EntityCacheUtil.removeResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
154                            ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey());
155    
156                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_NUMBER,
157                            new Object[] { shoppingOrder.getNumber() });
158    
159                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_PPTXNID,
160                            new Object[] { shoppingOrder.getPpTxnId() });
161            }
162    
163            public ShoppingOrder create(long orderId) {
164                    ShoppingOrder shoppingOrder = new ShoppingOrderImpl();
165    
166                    shoppingOrder.setNew(true);
167                    shoppingOrder.setPrimaryKey(orderId);
168    
169                    return shoppingOrder;
170            }
171    
172            public ShoppingOrder remove(Serializable primaryKey)
173                    throws NoSuchModelException, SystemException {
174                    return remove(((Long)primaryKey).longValue());
175            }
176    
177            public ShoppingOrder remove(long orderId)
178                    throws NoSuchOrderException, SystemException {
179                    Session session = null;
180    
181                    try {
182                            session = openSession();
183    
184                            ShoppingOrder shoppingOrder = (ShoppingOrder)session.get(ShoppingOrderImpl.class,
185                                            new Long(orderId));
186    
187                            if (shoppingOrder == null) {
188                                    if (_log.isWarnEnabled()) {
189                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + orderId);
190                                    }
191    
192                                    throw new NoSuchOrderException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
193                                            orderId);
194                            }
195    
196                            return remove(shoppingOrder);
197                    }
198                    catch (NoSuchOrderException nsee) {
199                            throw nsee;
200                    }
201                    catch (Exception e) {
202                            throw processException(e);
203                    }
204                    finally {
205                            closeSession(session);
206                    }
207            }
208    
209            protected ShoppingOrder removeImpl(ShoppingOrder shoppingOrder)
210                    throws SystemException {
211                    shoppingOrder = toUnwrappedModel(shoppingOrder);
212    
213                    Session session = null;
214    
215                    try {
216                            session = openSession();
217    
218                            if (shoppingOrder.isCachedModel() || BatchSessionUtil.isEnabled()) {
219                                    Object staleObject = session.get(ShoppingOrderImpl.class,
220                                                    shoppingOrder.getPrimaryKeyObj());
221    
222                                    if (staleObject != null) {
223                                            session.evict(staleObject);
224                                    }
225                            }
226    
227                            session.delete(shoppingOrder);
228    
229                            session.flush();
230                    }
231                    catch (Exception e) {
232                            throw processException(e);
233                    }
234                    finally {
235                            closeSession(session);
236                    }
237    
238                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
239    
240                    ShoppingOrderModelImpl shoppingOrderModelImpl = (ShoppingOrderModelImpl)shoppingOrder;
241    
242                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_NUMBER,
243                            new Object[] { shoppingOrderModelImpl.getOriginalNumber() });
244    
245                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_PPTXNID,
246                            new Object[] { shoppingOrderModelImpl.getOriginalPpTxnId() });
247    
248                    EntityCacheUtil.removeResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
249                            ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey());
250    
251                    return shoppingOrder;
252            }
253    
254            public ShoppingOrder updateImpl(
255                    com.liferay.portlet.shopping.model.ShoppingOrder shoppingOrder,
256                    boolean merge) throws SystemException {
257                    shoppingOrder = toUnwrappedModel(shoppingOrder);
258    
259                    boolean isNew = shoppingOrder.isNew();
260    
261                    ShoppingOrderModelImpl shoppingOrderModelImpl = (ShoppingOrderModelImpl)shoppingOrder;
262    
263                    Session session = null;
264    
265                    try {
266                            session = openSession();
267    
268                            BatchSessionUtil.update(session, shoppingOrder, merge);
269    
270                            shoppingOrder.setNew(false);
271                    }
272                    catch (Exception e) {
273                            throw processException(e);
274                    }
275                    finally {
276                            closeSession(session);
277                    }
278    
279                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
280    
281                    EntityCacheUtil.putResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
282                            ShoppingOrderImpl.class, shoppingOrder.getPrimaryKey(),
283                            shoppingOrder);
284    
285                    if (!isNew &&
286                                    (!Validator.equals(shoppingOrder.getNumber(),
287                                            shoppingOrderModelImpl.getOriginalNumber()))) {
288                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_NUMBER,
289                                    new Object[] { shoppingOrderModelImpl.getOriginalNumber() });
290                    }
291    
292                    if (isNew ||
293                                    (!Validator.equals(shoppingOrder.getNumber(),
294                                            shoppingOrderModelImpl.getOriginalNumber()))) {
295                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
296                                    new Object[] { shoppingOrder.getNumber() }, shoppingOrder);
297                    }
298    
299                    if (!isNew &&
300                                    (!Validator.equals(shoppingOrder.getPpTxnId(),
301                                            shoppingOrderModelImpl.getOriginalPpTxnId()))) {
302                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_PPTXNID,
303                                    new Object[] { shoppingOrderModelImpl.getOriginalPpTxnId() });
304                    }
305    
306                    if (isNew ||
307                                    (!Validator.equals(shoppingOrder.getPpTxnId(),
308                                            shoppingOrderModelImpl.getOriginalPpTxnId()))) {
309                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
310                                    new Object[] { shoppingOrder.getPpTxnId() }, shoppingOrder);
311                    }
312    
313                    return shoppingOrder;
314            }
315    
316            protected ShoppingOrder toUnwrappedModel(ShoppingOrder shoppingOrder) {
317                    if (shoppingOrder instanceof ShoppingOrderImpl) {
318                            return shoppingOrder;
319                    }
320    
321                    ShoppingOrderImpl shoppingOrderImpl = new ShoppingOrderImpl();
322    
323                    shoppingOrderImpl.setNew(shoppingOrder.isNew());
324                    shoppingOrderImpl.setPrimaryKey(shoppingOrder.getPrimaryKey());
325    
326                    shoppingOrderImpl.setOrderId(shoppingOrder.getOrderId());
327                    shoppingOrderImpl.setGroupId(shoppingOrder.getGroupId());
328                    shoppingOrderImpl.setCompanyId(shoppingOrder.getCompanyId());
329                    shoppingOrderImpl.setUserId(shoppingOrder.getUserId());
330                    shoppingOrderImpl.setUserName(shoppingOrder.getUserName());
331                    shoppingOrderImpl.setCreateDate(shoppingOrder.getCreateDate());
332                    shoppingOrderImpl.setModifiedDate(shoppingOrder.getModifiedDate());
333                    shoppingOrderImpl.setNumber(shoppingOrder.getNumber());
334                    shoppingOrderImpl.setTax(shoppingOrder.getTax());
335                    shoppingOrderImpl.setShipping(shoppingOrder.getShipping());
336                    shoppingOrderImpl.setAltShipping(shoppingOrder.getAltShipping());
337                    shoppingOrderImpl.setRequiresShipping(shoppingOrder.isRequiresShipping());
338                    shoppingOrderImpl.setInsure(shoppingOrder.isInsure());
339                    shoppingOrderImpl.setInsurance(shoppingOrder.getInsurance());
340                    shoppingOrderImpl.setCouponCodes(shoppingOrder.getCouponCodes());
341                    shoppingOrderImpl.setCouponDiscount(shoppingOrder.getCouponDiscount());
342                    shoppingOrderImpl.setBillingFirstName(shoppingOrder.getBillingFirstName());
343                    shoppingOrderImpl.setBillingLastName(shoppingOrder.getBillingLastName());
344                    shoppingOrderImpl.setBillingEmailAddress(shoppingOrder.getBillingEmailAddress());
345                    shoppingOrderImpl.setBillingCompany(shoppingOrder.getBillingCompany());
346                    shoppingOrderImpl.setBillingStreet(shoppingOrder.getBillingStreet());
347                    shoppingOrderImpl.setBillingCity(shoppingOrder.getBillingCity());
348                    shoppingOrderImpl.setBillingState(shoppingOrder.getBillingState());
349                    shoppingOrderImpl.setBillingZip(shoppingOrder.getBillingZip());
350                    shoppingOrderImpl.setBillingCountry(shoppingOrder.getBillingCountry());
351                    shoppingOrderImpl.setBillingPhone(shoppingOrder.getBillingPhone());
352                    shoppingOrderImpl.setShipToBilling(shoppingOrder.isShipToBilling());
353                    shoppingOrderImpl.setShippingFirstName(shoppingOrder.getShippingFirstName());
354                    shoppingOrderImpl.setShippingLastName(shoppingOrder.getShippingLastName());
355                    shoppingOrderImpl.setShippingEmailAddress(shoppingOrder.getShippingEmailAddress());
356                    shoppingOrderImpl.setShippingCompany(shoppingOrder.getShippingCompany());
357                    shoppingOrderImpl.setShippingStreet(shoppingOrder.getShippingStreet());
358                    shoppingOrderImpl.setShippingCity(shoppingOrder.getShippingCity());
359                    shoppingOrderImpl.setShippingState(shoppingOrder.getShippingState());
360                    shoppingOrderImpl.setShippingZip(shoppingOrder.getShippingZip());
361                    shoppingOrderImpl.setShippingCountry(shoppingOrder.getShippingCountry());
362                    shoppingOrderImpl.setShippingPhone(shoppingOrder.getShippingPhone());
363                    shoppingOrderImpl.setCcName(shoppingOrder.getCcName());
364                    shoppingOrderImpl.setCcType(shoppingOrder.getCcType());
365                    shoppingOrderImpl.setCcNumber(shoppingOrder.getCcNumber());
366                    shoppingOrderImpl.setCcExpMonth(shoppingOrder.getCcExpMonth());
367                    shoppingOrderImpl.setCcExpYear(shoppingOrder.getCcExpYear());
368                    shoppingOrderImpl.setCcVerNumber(shoppingOrder.getCcVerNumber());
369                    shoppingOrderImpl.setComments(shoppingOrder.getComments());
370                    shoppingOrderImpl.setPpTxnId(shoppingOrder.getPpTxnId());
371                    shoppingOrderImpl.setPpPaymentStatus(shoppingOrder.getPpPaymentStatus());
372                    shoppingOrderImpl.setPpPaymentGross(shoppingOrder.getPpPaymentGross());
373                    shoppingOrderImpl.setPpReceiverEmail(shoppingOrder.getPpReceiverEmail());
374                    shoppingOrderImpl.setPpPayerEmail(shoppingOrder.getPpPayerEmail());
375                    shoppingOrderImpl.setSendOrderEmail(shoppingOrder.isSendOrderEmail());
376                    shoppingOrderImpl.setSendShippingEmail(shoppingOrder.isSendShippingEmail());
377    
378                    return shoppingOrderImpl;
379            }
380    
381            public ShoppingOrder findByPrimaryKey(Serializable primaryKey)
382                    throws NoSuchModelException, SystemException {
383                    return findByPrimaryKey(((Long)primaryKey).longValue());
384            }
385    
386            public ShoppingOrder findByPrimaryKey(long orderId)
387                    throws NoSuchOrderException, SystemException {
388                    ShoppingOrder shoppingOrder = fetchByPrimaryKey(orderId);
389    
390                    if (shoppingOrder == null) {
391                            if (_log.isWarnEnabled()) {
392                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + orderId);
393                            }
394    
395                            throw new NoSuchOrderException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
396                                    orderId);
397                    }
398    
399                    return shoppingOrder;
400            }
401    
402            public ShoppingOrder fetchByPrimaryKey(Serializable primaryKey)
403                    throws SystemException {
404                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
405            }
406    
407            public ShoppingOrder fetchByPrimaryKey(long orderId)
408                    throws SystemException {
409                    ShoppingOrder shoppingOrder = (ShoppingOrder)EntityCacheUtil.getResult(ShoppingOrderModelImpl.ENTITY_CACHE_ENABLED,
410                                    ShoppingOrderImpl.class, orderId, this);
411    
412                    if (shoppingOrder == null) {
413                            Session session = null;
414    
415                            try {
416                                    session = openSession();
417    
418                                    shoppingOrder = (ShoppingOrder)session.get(ShoppingOrderImpl.class,
419                                                    new Long(orderId));
420                            }
421                            catch (Exception e) {
422                                    throw processException(e);
423                            }
424                            finally {
425                                    if (shoppingOrder != null) {
426                                            cacheResult(shoppingOrder);
427                                    }
428    
429                                    closeSession(session);
430                            }
431                    }
432    
433                    return shoppingOrder;
434            }
435    
436            public List<ShoppingOrder> findByGroupId(long groupId)
437                    throws SystemException {
438                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
439            }
440    
441            public List<ShoppingOrder> findByGroupId(long groupId, int start, int end)
442                    throws SystemException {
443                    return findByGroupId(groupId, start, end, null);
444            }
445    
446            public List<ShoppingOrder> findByGroupId(long groupId, int start, int end,
447                    OrderByComparator orderByComparator) throws SystemException {
448                    Object[] finderArgs = new Object[] {
449                                    groupId,
450                                    
451                                    String.valueOf(start), String.valueOf(end),
452                                    String.valueOf(orderByComparator)
453                            };
454    
455                    List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
456                                    finderArgs, this);
457    
458                    if (list == null) {
459                            Session session = null;
460    
461                            try {
462                                    session = openSession();
463    
464                                    StringBundler query = null;
465    
466                                    if (orderByComparator != null) {
467                                            query = new StringBundler(3 +
468                                                            (orderByComparator.getOrderByFields().length * 3));
469                                    }
470                                    else {
471                                            query = new StringBundler(3);
472                                    }
473    
474                                    query.append(_SQL_SELECT_SHOPPINGORDER_WHERE);
475    
476                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
477    
478                                    if (orderByComparator != null) {
479                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
480                                                    orderByComparator);
481                                    }
482    
483                                    else {
484                                            query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
485                                    }
486    
487                                    String sql = query.toString();
488    
489                                    Query q = session.createQuery(sql);
490    
491                                    QueryPos qPos = QueryPos.getInstance(q);
492    
493                                    qPos.add(groupId);
494    
495                                    list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
496                                                    start, end);
497                            }
498                            catch (Exception e) {
499                                    throw processException(e);
500                            }
501                            finally {
502                                    if (list == null) {
503                                            list = new ArrayList<ShoppingOrder>();
504                                    }
505    
506                                    cacheResult(list);
507    
508                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
509                                            finderArgs, list);
510    
511                                    closeSession(session);
512                            }
513                    }
514    
515                    return list;
516            }
517    
518            public ShoppingOrder findByGroupId_First(long groupId,
519                    OrderByComparator orderByComparator)
520                    throws NoSuchOrderException, SystemException {
521                    List<ShoppingOrder> list = findByGroupId(groupId, 0, 1,
522                                    orderByComparator);
523    
524                    if (list.isEmpty()) {
525                            StringBundler msg = new StringBundler(4);
526    
527                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
528    
529                            msg.append("groupId=");
530                            msg.append(groupId);
531    
532                            msg.append(StringPool.CLOSE_CURLY_BRACE);
533    
534                            throw new NoSuchOrderException(msg.toString());
535                    }
536                    else {
537                            return list.get(0);
538                    }
539            }
540    
541            public ShoppingOrder findByGroupId_Last(long groupId,
542                    OrderByComparator orderByComparator)
543                    throws NoSuchOrderException, SystemException {
544                    int count = countByGroupId(groupId);
545    
546                    List<ShoppingOrder> list = findByGroupId(groupId, count - 1, count,
547                                    orderByComparator);
548    
549                    if (list.isEmpty()) {
550                            StringBundler msg = new StringBundler(4);
551    
552                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
553    
554                            msg.append("groupId=");
555                            msg.append(groupId);
556    
557                            msg.append(StringPool.CLOSE_CURLY_BRACE);
558    
559                            throw new NoSuchOrderException(msg.toString());
560                    }
561                    else {
562                            return list.get(0);
563                    }
564            }
565    
566            public ShoppingOrder[] findByGroupId_PrevAndNext(long orderId,
567                    long groupId, OrderByComparator orderByComparator)
568                    throws NoSuchOrderException, SystemException {
569                    ShoppingOrder shoppingOrder = findByPrimaryKey(orderId);
570    
571                    Session session = null;
572    
573                    try {
574                            session = openSession();
575    
576                            ShoppingOrder[] array = new ShoppingOrderImpl[3];
577    
578                            array[0] = getByGroupId_PrevAndNext(session, shoppingOrder,
579                                            groupId, orderByComparator, true);
580    
581                            array[1] = shoppingOrder;
582    
583                            array[2] = getByGroupId_PrevAndNext(session, shoppingOrder,
584                                            groupId, orderByComparator, false);
585    
586                            return array;
587                    }
588                    catch (Exception e) {
589                            throw processException(e);
590                    }
591                    finally {
592                            closeSession(session);
593                    }
594            }
595    
596            protected ShoppingOrder getByGroupId_PrevAndNext(Session session,
597                    ShoppingOrder shoppingOrder, long groupId,
598                    OrderByComparator orderByComparator, boolean previous) {
599                    StringBundler query = null;
600    
601                    if (orderByComparator != null) {
602                            query = new StringBundler(6 +
603                                            (orderByComparator.getOrderByFields().length * 6));
604                    }
605                    else {
606                            query = new StringBundler(3);
607                    }
608    
609                    query.append(_SQL_SELECT_SHOPPINGORDER_WHERE);
610    
611                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
612    
613                    if (orderByComparator != null) {
614                            String[] orderByFields = orderByComparator.getOrderByFields();
615    
616                            if (orderByFields.length > 0) {
617                                    query.append(WHERE_AND);
618                            }
619    
620                            for (int i = 0; i < orderByFields.length; i++) {
621                                    query.append(_ORDER_BY_ENTITY_ALIAS);
622                                    query.append(orderByFields[i]);
623    
624                                    if ((i + 1) < orderByFields.length) {
625                                            if (orderByComparator.isAscending() ^ previous) {
626                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
627                                            }
628                                            else {
629                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
630                                            }
631                                    }
632                                    else {
633                                            if (orderByComparator.isAscending() ^ previous) {
634                                                    query.append(WHERE_GREATER_THAN);
635                                            }
636                                            else {
637                                                    query.append(WHERE_LESSER_THAN);
638                                            }
639                                    }
640                            }
641    
642                            query.append(ORDER_BY_CLAUSE);
643    
644                            for (int i = 0; i < orderByFields.length; i++) {
645                                    query.append(_ORDER_BY_ENTITY_ALIAS);
646                                    query.append(orderByFields[i]);
647    
648                                    if ((i + 1) < orderByFields.length) {
649                                            if (orderByComparator.isAscending() ^ previous) {
650                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
651                                            }
652                                            else {
653                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
654                                            }
655                                    }
656                                    else {
657                                            if (orderByComparator.isAscending() ^ previous) {
658                                                    query.append(ORDER_BY_ASC);
659                                            }
660                                            else {
661                                                    query.append(ORDER_BY_DESC);
662                                            }
663                                    }
664                            }
665                    }
666    
667                    else {
668                            query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
669                    }
670    
671                    String sql = query.toString();
672    
673                    Query q = session.createQuery(sql);
674    
675                    q.setFirstResult(0);
676                    q.setMaxResults(2);
677    
678                    QueryPos qPos = QueryPos.getInstance(q);
679    
680                    qPos.add(groupId);
681    
682                    if (orderByComparator != null) {
683                            Object[] values = orderByComparator.getOrderByValues(shoppingOrder);
684    
685                            for (Object value : values) {
686                                    qPos.add(value);
687                            }
688                    }
689    
690                    List<ShoppingOrder> list = q.list();
691    
692                    if (list.size() == 2) {
693                            return list.get(1);
694                    }
695                    else {
696                            return null;
697                    }
698            }
699    
700            public List<ShoppingOrder> filterFindByGroupId(long groupId)
701                    throws SystemException {
702                    return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
703                            QueryUtil.ALL_POS, null);
704            }
705    
706            public List<ShoppingOrder> filterFindByGroupId(long groupId, int start,
707                    int end) throws SystemException {
708                    return filterFindByGroupId(groupId, start, end, null);
709            }
710    
711            public List<ShoppingOrder> filterFindByGroupId(long groupId, int start,
712                    int end, OrderByComparator orderByComparator) throws SystemException {
713                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
714                            return findByGroupId(groupId, start, end, orderByComparator);
715                    }
716    
717                    Session session = null;
718    
719                    try {
720                            session = openSession();
721    
722                            StringBundler query = null;
723    
724                            if (orderByComparator != null) {
725                                    query = new StringBundler(3 +
726                                                    (orderByComparator.getOrderByFields().length * 3));
727                            }
728                            else {
729                                    query = new StringBundler(3);
730                            }
731    
732                            query.append(_FILTER_SQL_SELECT_SHOPPINGORDER_WHERE);
733    
734                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
735    
736                            if (orderByComparator != null) {
737                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
738                                            orderByComparator);
739                            }
740    
741                            else {
742                                    query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
743                            }
744    
745                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
746                                            ShoppingOrder.class.getName(), _FILTER_COLUMN_PK,
747                                            _FILTER_COLUMN_USERID, groupId);
748    
749                            SQLQuery q = session.createSQLQuery(sql);
750    
751                            q.addEntity(_FILTER_ENTITY_ALIAS, ShoppingOrderImpl.class);
752    
753                            QueryPos qPos = QueryPos.getInstance(q);
754    
755                            qPos.add(groupId);
756    
757                            return (List<ShoppingOrder>)QueryUtil.list(q, getDialect(), start,
758                                    end);
759                    }
760                    catch (Exception e) {
761                            throw processException(e);
762                    }
763                    finally {
764                            closeSession(session);
765                    }
766            }
767    
768            public ShoppingOrder findByNumber(String number)
769                    throws NoSuchOrderException, SystemException {
770                    ShoppingOrder shoppingOrder = fetchByNumber(number);
771    
772                    if (shoppingOrder == null) {
773                            StringBundler msg = new StringBundler(4);
774    
775                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
776    
777                            msg.append("number=");
778                            msg.append(number);
779    
780                            msg.append(StringPool.CLOSE_CURLY_BRACE);
781    
782                            if (_log.isWarnEnabled()) {
783                                    _log.warn(msg.toString());
784                            }
785    
786                            throw new NoSuchOrderException(msg.toString());
787                    }
788    
789                    return shoppingOrder;
790            }
791    
792            public ShoppingOrder fetchByNumber(String number) throws SystemException {
793                    return fetchByNumber(number, true);
794            }
795    
796            public ShoppingOrder fetchByNumber(String number, boolean retrieveFromCache)
797                    throws SystemException {
798                    Object[] finderArgs = new Object[] { number };
799    
800                    Object result = null;
801    
802                    if (retrieveFromCache) {
803                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_NUMBER,
804                                            finderArgs, this);
805                    }
806    
807                    if (result == null) {
808                            Session session = null;
809    
810                            try {
811                                    session = openSession();
812    
813                                    StringBundler query = new StringBundler(3);
814    
815                                    query.append(_SQL_SELECT_SHOPPINGORDER_WHERE);
816    
817                                    if (number == null) {
818                                            query.append(_FINDER_COLUMN_NUMBER_NUMBER_1);
819                                    }
820                                    else {
821                                            if (number.equals(StringPool.BLANK)) {
822                                                    query.append(_FINDER_COLUMN_NUMBER_NUMBER_3);
823                                            }
824                                            else {
825                                                    query.append(_FINDER_COLUMN_NUMBER_NUMBER_2);
826                                            }
827                                    }
828    
829                                    query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
830    
831                                    String sql = query.toString();
832    
833                                    Query q = session.createQuery(sql);
834    
835                                    QueryPos qPos = QueryPos.getInstance(q);
836    
837                                    if (number != null) {
838                                            qPos.add(number);
839                                    }
840    
841                                    List<ShoppingOrder> list = q.list();
842    
843                                    result = list;
844    
845                                    ShoppingOrder shoppingOrder = null;
846    
847                                    if (list.isEmpty()) {
848                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
849                                                    finderArgs, list);
850                                    }
851                                    else {
852                                            shoppingOrder = list.get(0);
853    
854                                            cacheResult(shoppingOrder);
855    
856                                            if ((shoppingOrder.getNumber() == null) ||
857                                                            !shoppingOrder.getNumber().equals(number)) {
858                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
859                                                            finderArgs, shoppingOrder);
860                                            }
861                                    }
862    
863                                    return shoppingOrder;
864                            }
865                            catch (Exception e) {
866                                    throw processException(e);
867                            }
868                            finally {
869                                    if (result == null) {
870                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_NUMBER,
871                                                    finderArgs, new ArrayList<ShoppingOrder>());
872                                    }
873    
874                                    closeSession(session);
875                            }
876                    }
877                    else {
878                            if (result instanceof List<?>) {
879                                    return null;
880                            }
881                            else {
882                                    return (ShoppingOrder)result;
883                            }
884                    }
885            }
886    
887            public ShoppingOrder findByPPTxnId(String ppTxnId)
888                    throws NoSuchOrderException, SystemException {
889                    ShoppingOrder shoppingOrder = fetchByPPTxnId(ppTxnId);
890    
891                    if (shoppingOrder == null) {
892                            StringBundler msg = new StringBundler(4);
893    
894                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
895    
896                            msg.append("ppTxnId=");
897                            msg.append(ppTxnId);
898    
899                            msg.append(StringPool.CLOSE_CURLY_BRACE);
900    
901                            if (_log.isWarnEnabled()) {
902                                    _log.warn(msg.toString());
903                            }
904    
905                            throw new NoSuchOrderException(msg.toString());
906                    }
907    
908                    return shoppingOrder;
909            }
910    
911            public ShoppingOrder fetchByPPTxnId(String ppTxnId)
912                    throws SystemException {
913                    return fetchByPPTxnId(ppTxnId, true);
914            }
915    
916            public ShoppingOrder fetchByPPTxnId(String ppTxnId,
917                    boolean retrieveFromCache) throws SystemException {
918                    Object[] finderArgs = new Object[] { ppTxnId };
919    
920                    Object result = null;
921    
922                    if (retrieveFromCache) {
923                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_PPTXNID,
924                                            finderArgs, this);
925                    }
926    
927                    if (result == null) {
928                            Session session = null;
929    
930                            try {
931                                    session = openSession();
932    
933                                    StringBundler query = new StringBundler(3);
934    
935                                    query.append(_SQL_SELECT_SHOPPINGORDER_WHERE);
936    
937                                    if (ppTxnId == null) {
938                                            query.append(_FINDER_COLUMN_PPTXNID_PPTXNID_1);
939                                    }
940                                    else {
941                                            if (ppTxnId.equals(StringPool.BLANK)) {
942                                                    query.append(_FINDER_COLUMN_PPTXNID_PPTXNID_3);
943                                            }
944                                            else {
945                                                    query.append(_FINDER_COLUMN_PPTXNID_PPTXNID_2);
946                                            }
947                                    }
948    
949                                    query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
950    
951                                    String sql = query.toString();
952    
953                                    Query q = session.createQuery(sql);
954    
955                                    QueryPos qPos = QueryPos.getInstance(q);
956    
957                                    if (ppTxnId != null) {
958                                            qPos.add(ppTxnId);
959                                    }
960    
961                                    List<ShoppingOrder> list = q.list();
962    
963                                    result = list;
964    
965                                    ShoppingOrder shoppingOrder = null;
966    
967                                    if (list.isEmpty()) {
968                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
969                                                    finderArgs, list);
970                                    }
971                                    else {
972                                            shoppingOrder = list.get(0);
973    
974                                            cacheResult(shoppingOrder);
975    
976                                            if ((shoppingOrder.getPpTxnId() == null) ||
977                                                            !shoppingOrder.getPpTxnId().equals(ppTxnId)) {
978                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
979                                                            finderArgs, shoppingOrder);
980                                            }
981                                    }
982    
983                                    return shoppingOrder;
984                            }
985                            catch (Exception e) {
986                                    throw processException(e);
987                            }
988                            finally {
989                                    if (result == null) {
990                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_PPTXNID,
991                                                    finderArgs, new ArrayList<ShoppingOrder>());
992                                    }
993    
994                                    closeSession(session);
995                            }
996                    }
997                    else {
998                            if (result instanceof List<?>) {
999                                    return null;
1000                            }
1001                            else {
1002                                    return (ShoppingOrder)result;
1003                            }
1004                    }
1005            }
1006    
1007            public List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId,
1008                    String ppPaymentStatus) throws SystemException {
1009                    return findByG_U_PPPS(groupId, userId, ppPaymentStatus,
1010                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1011            }
1012    
1013            public List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId,
1014                    String ppPaymentStatus, int start, int end) throws SystemException {
1015                    return findByG_U_PPPS(groupId, userId, ppPaymentStatus, start, end, null);
1016            }
1017    
1018            public List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId,
1019                    String ppPaymentStatus, int start, int end,
1020                    OrderByComparator orderByComparator) throws SystemException {
1021                    Object[] finderArgs = new Object[] {
1022                                    groupId, userId, ppPaymentStatus,
1023                                    
1024                                    String.valueOf(start), String.valueOf(end),
1025                                    String.valueOf(orderByComparator)
1026                            };
1027    
1028                    List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_PPPS,
1029                                    finderArgs, this);
1030    
1031                    if (list == null) {
1032                            Session session = null;
1033    
1034                            try {
1035                                    session = openSession();
1036    
1037                                    StringBundler query = null;
1038    
1039                                    if (orderByComparator != null) {
1040                                            query = new StringBundler(5 +
1041                                                            (orderByComparator.getOrderByFields().length * 3));
1042                                    }
1043                                    else {
1044                                            query = new StringBundler(5);
1045                                    }
1046    
1047                                    query.append(_SQL_SELECT_SHOPPINGORDER_WHERE);
1048    
1049                                    query.append(_FINDER_COLUMN_G_U_PPPS_GROUPID_2);
1050    
1051                                    query.append(_FINDER_COLUMN_G_U_PPPS_USERID_2);
1052    
1053                                    if (ppPaymentStatus == null) {
1054                                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_1);
1055                                    }
1056                                    else {
1057                                            if (ppPaymentStatus.equals(StringPool.BLANK)) {
1058                                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_3);
1059                                            }
1060                                            else {
1061                                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_2);
1062                                            }
1063                                    }
1064    
1065                                    if (orderByComparator != null) {
1066                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1067                                                    orderByComparator);
1068                                    }
1069    
1070                                    else {
1071                                            query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
1072                                    }
1073    
1074                                    String sql = query.toString();
1075    
1076                                    Query q = session.createQuery(sql);
1077    
1078                                    QueryPos qPos = QueryPos.getInstance(q);
1079    
1080                                    qPos.add(groupId);
1081    
1082                                    qPos.add(userId);
1083    
1084                                    if (ppPaymentStatus != null) {
1085                                            qPos.add(ppPaymentStatus);
1086                                    }
1087    
1088                                    list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
1089                                                    start, end);
1090                            }
1091                            catch (Exception e) {
1092                                    throw processException(e);
1093                            }
1094                            finally {
1095                                    if (list == null) {
1096                                            list = new ArrayList<ShoppingOrder>();
1097                                    }
1098    
1099                                    cacheResult(list);
1100    
1101                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_PPPS,
1102                                            finderArgs, list);
1103    
1104                                    closeSession(session);
1105                            }
1106                    }
1107    
1108                    return list;
1109            }
1110    
1111            public ShoppingOrder findByG_U_PPPS_First(long groupId, long userId,
1112                    String ppPaymentStatus, OrderByComparator orderByComparator)
1113                    throws NoSuchOrderException, SystemException {
1114                    List<ShoppingOrder> list = findByG_U_PPPS(groupId, userId,
1115                                    ppPaymentStatus, 0, 1, orderByComparator);
1116    
1117                    if (list.isEmpty()) {
1118                            StringBundler msg = new StringBundler(8);
1119    
1120                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1121    
1122                            msg.append("groupId=");
1123                            msg.append(groupId);
1124    
1125                            msg.append(", userId=");
1126                            msg.append(userId);
1127    
1128                            msg.append(", ppPaymentStatus=");
1129                            msg.append(ppPaymentStatus);
1130    
1131                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1132    
1133                            throw new NoSuchOrderException(msg.toString());
1134                    }
1135                    else {
1136                            return list.get(0);
1137                    }
1138            }
1139    
1140            public ShoppingOrder findByG_U_PPPS_Last(long groupId, long userId,
1141                    String ppPaymentStatus, OrderByComparator orderByComparator)
1142                    throws NoSuchOrderException, SystemException {
1143                    int count = countByG_U_PPPS(groupId, userId, ppPaymentStatus);
1144    
1145                    List<ShoppingOrder> list = findByG_U_PPPS(groupId, userId,
1146                                    ppPaymentStatus, count - 1, count, orderByComparator);
1147    
1148                    if (list.isEmpty()) {
1149                            StringBundler msg = new StringBundler(8);
1150    
1151                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1152    
1153                            msg.append("groupId=");
1154                            msg.append(groupId);
1155    
1156                            msg.append(", userId=");
1157                            msg.append(userId);
1158    
1159                            msg.append(", ppPaymentStatus=");
1160                            msg.append(ppPaymentStatus);
1161    
1162                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1163    
1164                            throw new NoSuchOrderException(msg.toString());
1165                    }
1166                    else {
1167                            return list.get(0);
1168                    }
1169            }
1170    
1171            public ShoppingOrder[] findByG_U_PPPS_PrevAndNext(long orderId,
1172                    long groupId, long userId, String ppPaymentStatus,
1173                    OrderByComparator orderByComparator)
1174                    throws NoSuchOrderException, SystemException {
1175                    ShoppingOrder shoppingOrder = findByPrimaryKey(orderId);
1176    
1177                    Session session = null;
1178    
1179                    try {
1180                            session = openSession();
1181    
1182                            ShoppingOrder[] array = new ShoppingOrderImpl[3];
1183    
1184                            array[0] = getByG_U_PPPS_PrevAndNext(session, shoppingOrder,
1185                                            groupId, userId, ppPaymentStatus, orderByComparator, true);
1186    
1187                            array[1] = shoppingOrder;
1188    
1189                            array[2] = getByG_U_PPPS_PrevAndNext(session, shoppingOrder,
1190                                            groupId, userId, ppPaymentStatus, orderByComparator, false);
1191    
1192                            return array;
1193                    }
1194                    catch (Exception e) {
1195                            throw processException(e);
1196                    }
1197                    finally {
1198                            closeSession(session);
1199                    }
1200            }
1201    
1202            protected ShoppingOrder getByG_U_PPPS_PrevAndNext(Session session,
1203                    ShoppingOrder shoppingOrder, long groupId, long userId,
1204                    String ppPaymentStatus, OrderByComparator orderByComparator,
1205                    boolean previous) {
1206                    StringBundler query = null;
1207    
1208                    if (orderByComparator != null) {
1209                            query = new StringBundler(6 +
1210                                            (orderByComparator.getOrderByFields().length * 6));
1211                    }
1212                    else {
1213                            query = new StringBundler(3);
1214                    }
1215    
1216                    query.append(_SQL_SELECT_SHOPPINGORDER_WHERE);
1217    
1218                    query.append(_FINDER_COLUMN_G_U_PPPS_GROUPID_2);
1219    
1220                    query.append(_FINDER_COLUMN_G_U_PPPS_USERID_2);
1221    
1222                    if (ppPaymentStatus == null) {
1223                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_1);
1224                    }
1225                    else {
1226                            if (ppPaymentStatus.equals(StringPool.BLANK)) {
1227                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_3);
1228                            }
1229                            else {
1230                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_2);
1231                            }
1232                    }
1233    
1234                    if (orderByComparator != null) {
1235                            String[] orderByFields = orderByComparator.getOrderByFields();
1236    
1237                            if (orderByFields.length > 0) {
1238                                    query.append(WHERE_AND);
1239                            }
1240    
1241                            for (int i = 0; i < orderByFields.length; i++) {
1242                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1243                                    query.append(orderByFields[i]);
1244    
1245                                    if ((i + 1) < orderByFields.length) {
1246                                            if (orderByComparator.isAscending() ^ previous) {
1247                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1248                                            }
1249                                            else {
1250                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1251                                            }
1252                                    }
1253                                    else {
1254                                            if (orderByComparator.isAscending() ^ previous) {
1255                                                    query.append(WHERE_GREATER_THAN);
1256                                            }
1257                                            else {
1258                                                    query.append(WHERE_LESSER_THAN);
1259                                            }
1260                                    }
1261                            }
1262    
1263                            query.append(ORDER_BY_CLAUSE);
1264    
1265                            for (int i = 0; i < orderByFields.length; i++) {
1266                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1267                                    query.append(orderByFields[i]);
1268    
1269                                    if ((i + 1) < orderByFields.length) {
1270                                            if (orderByComparator.isAscending() ^ previous) {
1271                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1272                                            }
1273                                            else {
1274                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1275                                            }
1276                                    }
1277                                    else {
1278                                            if (orderByComparator.isAscending() ^ previous) {
1279                                                    query.append(ORDER_BY_ASC);
1280                                            }
1281                                            else {
1282                                                    query.append(ORDER_BY_DESC);
1283                                            }
1284                                    }
1285                            }
1286                    }
1287    
1288                    else {
1289                            query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
1290                    }
1291    
1292                    String sql = query.toString();
1293    
1294                    Query q = session.createQuery(sql);
1295    
1296                    q.setFirstResult(0);
1297                    q.setMaxResults(2);
1298    
1299                    QueryPos qPos = QueryPos.getInstance(q);
1300    
1301                    qPos.add(groupId);
1302    
1303                    qPos.add(userId);
1304    
1305                    if (ppPaymentStatus != null) {
1306                            qPos.add(ppPaymentStatus);
1307                    }
1308    
1309                    if (orderByComparator != null) {
1310                            Object[] values = orderByComparator.getOrderByValues(shoppingOrder);
1311    
1312                            for (Object value : values) {
1313                                    qPos.add(value);
1314                            }
1315                    }
1316    
1317                    List<ShoppingOrder> list = q.list();
1318    
1319                    if (list.size() == 2) {
1320                            return list.get(1);
1321                    }
1322                    else {
1323                            return null;
1324                    }
1325            }
1326    
1327            public List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, long userId,
1328                    String ppPaymentStatus) throws SystemException {
1329                    return filterFindByG_U_PPPS(groupId, userId, ppPaymentStatus,
1330                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1331            }
1332    
1333            public List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, long userId,
1334                    String ppPaymentStatus, int start, int end) throws SystemException {
1335                    return filterFindByG_U_PPPS(groupId, userId, ppPaymentStatus, start,
1336                            end, null);
1337            }
1338    
1339            public List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, long userId,
1340                    String ppPaymentStatus, int start, int end,
1341                    OrderByComparator orderByComparator) throws SystemException {
1342                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1343                            return findByG_U_PPPS(groupId, userId, ppPaymentStatus, start, end,
1344                                    orderByComparator);
1345                    }
1346    
1347                    Session session = null;
1348    
1349                    try {
1350                            session = openSession();
1351    
1352                            StringBundler query = null;
1353    
1354                            if (orderByComparator != null) {
1355                                    query = new StringBundler(5 +
1356                                                    (orderByComparator.getOrderByFields().length * 3));
1357                            }
1358                            else {
1359                                    query = new StringBundler(5);
1360                            }
1361    
1362                            query.append(_FILTER_SQL_SELECT_SHOPPINGORDER_WHERE);
1363    
1364                            query.append(_FINDER_COLUMN_G_U_PPPS_GROUPID_2);
1365    
1366                            query.append(_FINDER_COLUMN_G_U_PPPS_USERID_2);
1367    
1368                            if (ppPaymentStatus == null) {
1369                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_1);
1370                            }
1371                            else {
1372                                    if (ppPaymentStatus.equals(StringPool.BLANK)) {
1373                                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_3);
1374                                    }
1375                                    else {
1376                                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_2);
1377                                    }
1378                            }
1379    
1380                            if (orderByComparator != null) {
1381                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1382                                            orderByComparator);
1383                            }
1384    
1385                            else {
1386                                    query.append(ShoppingOrderModelImpl.ORDER_BY_JPQL);
1387                            }
1388    
1389                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1390                                            ShoppingOrder.class.getName(), _FILTER_COLUMN_PK,
1391                                            _FILTER_COLUMN_USERID, groupId);
1392    
1393                            SQLQuery q = session.createSQLQuery(sql);
1394    
1395                            q.addEntity(_FILTER_ENTITY_ALIAS, ShoppingOrderImpl.class);
1396    
1397                            QueryPos qPos = QueryPos.getInstance(q);
1398    
1399                            qPos.add(groupId);
1400    
1401                            qPos.add(userId);
1402    
1403                            if (ppPaymentStatus != null) {
1404                                    qPos.add(ppPaymentStatus);
1405                            }
1406    
1407                            return (List<ShoppingOrder>)QueryUtil.list(q, getDialect(), start,
1408                                    end);
1409                    }
1410                    catch (Exception e) {
1411                            throw processException(e);
1412                    }
1413                    finally {
1414                            closeSession(session);
1415                    }
1416            }
1417    
1418            public List<ShoppingOrder> findAll() throws SystemException {
1419                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1420            }
1421    
1422            public List<ShoppingOrder> findAll(int start, int end)
1423                    throws SystemException {
1424                    return findAll(start, end, null);
1425            }
1426    
1427            public List<ShoppingOrder> findAll(int start, int end,
1428                    OrderByComparator orderByComparator) throws SystemException {
1429                    Object[] finderArgs = new Object[] {
1430                                    String.valueOf(start), String.valueOf(end),
1431                                    String.valueOf(orderByComparator)
1432                            };
1433    
1434                    List<ShoppingOrder> list = (List<ShoppingOrder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1435                                    finderArgs, this);
1436    
1437                    if (list == null) {
1438                            Session session = null;
1439    
1440                            try {
1441                                    session = openSession();
1442    
1443                                    StringBundler query = null;
1444                                    String sql = null;
1445    
1446                                    if (orderByComparator != null) {
1447                                            query = new StringBundler(2 +
1448                                                            (orderByComparator.getOrderByFields().length * 3));
1449    
1450                                            query.append(_SQL_SELECT_SHOPPINGORDER);
1451    
1452                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1453                                                    orderByComparator);
1454    
1455                                            sql = query.toString();
1456                                    }
1457                                    else {
1458                                            sql = _SQL_SELECT_SHOPPINGORDER.concat(ShoppingOrderModelImpl.ORDER_BY_JPQL);
1459                                    }
1460    
1461                                    Query q = session.createQuery(sql);
1462    
1463                                    if (orderByComparator == null) {
1464                                            list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
1465                                                            start, end, false);
1466    
1467                                            Collections.sort(list);
1468                                    }
1469                                    else {
1470                                            list = (List<ShoppingOrder>)QueryUtil.list(q, getDialect(),
1471                                                            start, end);
1472                                    }
1473                            }
1474                            catch (Exception e) {
1475                                    throw processException(e);
1476                            }
1477                            finally {
1478                                    if (list == null) {
1479                                            list = new ArrayList<ShoppingOrder>();
1480                                    }
1481    
1482                                    cacheResult(list);
1483    
1484                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1485    
1486                                    closeSession(session);
1487                            }
1488                    }
1489    
1490                    return list;
1491            }
1492    
1493            public void removeByGroupId(long groupId) throws SystemException {
1494                    for (ShoppingOrder shoppingOrder : findByGroupId(groupId)) {
1495                            remove(shoppingOrder);
1496                    }
1497            }
1498    
1499            public void removeByNumber(String number)
1500                    throws NoSuchOrderException, SystemException {
1501                    ShoppingOrder shoppingOrder = findByNumber(number);
1502    
1503                    remove(shoppingOrder);
1504            }
1505    
1506            public void removeByPPTxnId(String ppTxnId)
1507                    throws NoSuchOrderException, SystemException {
1508                    ShoppingOrder shoppingOrder = findByPPTxnId(ppTxnId);
1509    
1510                    remove(shoppingOrder);
1511            }
1512    
1513            public void removeByG_U_PPPS(long groupId, long userId,
1514                    String ppPaymentStatus) throws SystemException {
1515                    for (ShoppingOrder shoppingOrder : findByG_U_PPPS(groupId, userId,
1516                                    ppPaymentStatus)) {
1517                            remove(shoppingOrder);
1518                    }
1519            }
1520    
1521            public void removeAll() throws SystemException {
1522                    for (ShoppingOrder shoppingOrder : findAll()) {
1523                            remove(shoppingOrder);
1524                    }
1525            }
1526    
1527            public int countByGroupId(long groupId) throws SystemException {
1528                    Object[] finderArgs = new Object[] { groupId };
1529    
1530                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1531                                    finderArgs, this);
1532    
1533                    if (count == null) {
1534                            Session session = null;
1535    
1536                            try {
1537                                    session = openSession();
1538    
1539                                    StringBundler query = new StringBundler(2);
1540    
1541                                    query.append(_SQL_COUNT_SHOPPINGORDER_WHERE);
1542    
1543                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1544    
1545                                    String sql = query.toString();
1546    
1547                                    Query q = session.createQuery(sql);
1548    
1549                                    QueryPos qPos = QueryPos.getInstance(q);
1550    
1551                                    qPos.add(groupId);
1552    
1553                                    count = (Long)q.uniqueResult();
1554                            }
1555                            catch (Exception e) {
1556                                    throw processException(e);
1557                            }
1558                            finally {
1559                                    if (count == null) {
1560                                            count = Long.valueOf(0);
1561                                    }
1562    
1563                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1564                                            finderArgs, count);
1565    
1566                                    closeSession(session);
1567                            }
1568                    }
1569    
1570                    return count.intValue();
1571            }
1572    
1573            public int filterCountByGroupId(long groupId) throws SystemException {
1574                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1575                            return countByGroupId(groupId);
1576                    }
1577    
1578                    Session session = null;
1579    
1580                    try {
1581                            session = openSession();
1582    
1583                            StringBundler query = new StringBundler(2);
1584    
1585                            query.append(_FILTER_SQL_COUNT_SHOPPINGORDER_WHERE);
1586    
1587                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1588    
1589                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1590                                            ShoppingOrder.class.getName(), _FILTER_COLUMN_PK,
1591                                            _FILTER_COLUMN_USERID, groupId);
1592    
1593                            SQLQuery q = session.createSQLQuery(sql);
1594    
1595                            q.addScalar(COUNT_COLUMN_NAME,
1596                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
1597    
1598                            QueryPos qPos = QueryPos.getInstance(q);
1599    
1600                            qPos.add(groupId);
1601    
1602                            Long count = (Long)q.uniqueResult();
1603    
1604                            return count.intValue();
1605                    }
1606                    catch (Exception e) {
1607                            throw processException(e);
1608                    }
1609                    finally {
1610                            closeSession(session);
1611                    }
1612            }
1613    
1614            public int countByNumber(String number) throws SystemException {
1615                    Object[] finderArgs = new Object[] { number };
1616    
1617                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_NUMBER,
1618                                    finderArgs, this);
1619    
1620                    if (count == null) {
1621                            Session session = null;
1622    
1623                            try {
1624                                    session = openSession();
1625    
1626                                    StringBundler query = new StringBundler(2);
1627    
1628                                    query.append(_SQL_COUNT_SHOPPINGORDER_WHERE);
1629    
1630                                    if (number == null) {
1631                                            query.append(_FINDER_COLUMN_NUMBER_NUMBER_1);
1632                                    }
1633                                    else {
1634                                            if (number.equals(StringPool.BLANK)) {
1635                                                    query.append(_FINDER_COLUMN_NUMBER_NUMBER_3);
1636                                            }
1637                                            else {
1638                                                    query.append(_FINDER_COLUMN_NUMBER_NUMBER_2);
1639                                            }
1640                                    }
1641    
1642                                    String sql = query.toString();
1643    
1644                                    Query q = session.createQuery(sql);
1645    
1646                                    QueryPos qPos = QueryPos.getInstance(q);
1647    
1648                                    if (number != null) {
1649                                            qPos.add(number);
1650                                    }
1651    
1652                                    count = (Long)q.uniqueResult();
1653                            }
1654                            catch (Exception e) {
1655                                    throw processException(e);
1656                            }
1657                            finally {
1658                                    if (count == null) {
1659                                            count = Long.valueOf(0);
1660                                    }
1661    
1662                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_NUMBER,
1663                                            finderArgs, count);
1664    
1665                                    closeSession(session);
1666                            }
1667                    }
1668    
1669                    return count.intValue();
1670            }
1671    
1672            public int countByPPTxnId(String ppTxnId) throws SystemException {
1673                    Object[] finderArgs = new Object[] { ppTxnId };
1674    
1675                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_PPTXNID,
1676                                    finderArgs, this);
1677    
1678                    if (count == null) {
1679                            Session session = null;
1680    
1681                            try {
1682                                    session = openSession();
1683    
1684                                    StringBundler query = new StringBundler(2);
1685    
1686                                    query.append(_SQL_COUNT_SHOPPINGORDER_WHERE);
1687    
1688                                    if (ppTxnId == null) {
1689                                            query.append(_FINDER_COLUMN_PPTXNID_PPTXNID_1);
1690                                    }
1691                                    else {
1692                                            if (ppTxnId.equals(StringPool.BLANK)) {
1693                                                    query.append(_FINDER_COLUMN_PPTXNID_PPTXNID_3);
1694                                            }
1695                                            else {
1696                                                    query.append(_FINDER_COLUMN_PPTXNID_PPTXNID_2);
1697                                            }
1698                                    }
1699    
1700                                    String sql = query.toString();
1701    
1702                                    Query q = session.createQuery(sql);
1703    
1704                                    QueryPos qPos = QueryPos.getInstance(q);
1705    
1706                                    if (ppTxnId != null) {
1707                                            qPos.add(ppTxnId);
1708                                    }
1709    
1710                                    count = (Long)q.uniqueResult();
1711                            }
1712                            catch (Exception e) {
1713                                    throw processException(e);
1714                            }
1715                            finally {
1716                                    if (count == null) {
1717                                            count = Long.valueOf(0);
1718                                    }
1719    
1720                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_PPTXNID,
1721                                            finderArgs, count);
1722    
1723                                    closeSession(session);
1724                            }
1725                    }
1726    
1727                    return count.intValue();
1728            }
1729    
1730            public int countByG_U_PPPS(long groupId, long userId, String ppPaymentStatus)
1731                    throws SystemException {
1732                    Object[] finderArgs = new Object[] { groupId, userId, ppPaymentStatus };
1733    
1734                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_PPPS,
1735                                    finderArgs, this);
1736    
1737                    if (count == null) {
1738                            Session session = null;
1739    
1740                            try {
1741                                    session = openSession();
1742    
1743                                    StringBundler query = new StringBundler(4);
1744    
1745                                    query.append(_SQL_COUNT_SHOPPINGORDER_WHERE);
1746    
1747                                    query.append(_FINDER_COLUMN_G_U_PPPS_GROUPID_2);
1748    
1749                                    query.append(_FINDER_COLUMN_G_U_PPPS_USERID_2);
1750    
1751                                    if (ppPaymentStatus == null) {
1752                                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_1);
1753                                    }
1754                                    else {
1755                                            if (ppPaymentStatus.equals(StringPool.BLANK)) {
1756                                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_3);
1757                                            }
1758                                            else {
1759                                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_2);
1760                                            }
1761                                    }
1762    
1763                                    String sql = query.toString();
1764    
1765                                    Query q = session.createQuery(sql);
1766    
1767                                    QueryPos qPos = QueryPos.getInstance(q);
1768    
1769                                    qPos.add(groupId);
1770    
1771                                    qPos.add(userId);
1772    
1773                                    if (ppPaymentStatus != null) {
1774                                            qPos.add(ppPaymentStatus);
1775                                    }
1776    
1777                                    count = (Long)q.uniqueResult();
1778                            }
1779                            catch (Exception e) {
1780                                    throw processException(e);
1781                            }
1782                            finally {
1783                                    if (count == null) {
1784                                            count = Long.valueOf(0);
1785                                    }
1786    
1787                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_PPPS,
1788                                            finderArgs, count);
1789    
1790                                    closeSession(session);
1791                            }
1792                    }
1793    
1794                    return count.intValue();
1795            }
1796    
1797            public int filterCountByG_U_PPPS(long groupId, long userId,
1798                    String ppPaymentStatus) throws SystemException {
1799                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1800                            return countByG_U_PPPS(groupId, userId, ppPaymentStatus);
1801                    }
1802    
1803                    Session session = null;
1804    
1805                    try {
1806                            session = openSession();
1807    
1808                            StringBundler query = new StringBundler(4);
1809    
1810                            query.append(_FILTER_SQL_COUNT_SHOPPINGORDER_WHERE);
1811    
1812                            query.append(_FINDER_COLUMN_G_U_PPPS_GROUPID_2);
1813    
1814                            query.append(_FINDER_COLUMN_G_U_PPPS_USERID_2);
1815    
1816                            if (ppPaymentStatus == null) {
1817                                    query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_1);
1818                            }
1819                            else {
1820                                    if (ppPaymentStatus.equals(StringPool.BLANK)) {
1821                                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_3);
1822                                    }
1823                                    else {
1824                                            query.append(_FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_2);
1825                                    }
1826                            }
1827    
1828                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1829                                            ShoppingOrder.class.getName(), _FILTER_COLUMN_PK,
1830                                            _FILTER_COLUMN_USERID, groupId);
1831    
1832                            SQLQuery q = session.createSQLQuery(sql);
1833    
1834                            q.addScalar(COUNT_COLUMN_NAME,
1835                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
1836    
1837                            QueryPos qPos = QueryPos.getInstance(q);
1838    
1839                            qPos.add(groupId);
1840    
1841                            qPos.add(userId);
1842    
1843                            if (ppPaymentStatus != null) {
1844                                    qPos.add(ppPaymentStatus);
1845                            }
1846    
1847                            Long count = (Long)q.uniqueResult();
1848    
1849                            return count.intValue();
1850                    }
1851                    catch (Exception e) {
1852                            throw processException(e);
1853                    }
1854                    finally {
1855                            closeSession(session);
1856                    }
1857            }
1858    
1859            public int countAll() throws SystemException {
1860                    Object[] finderArgs = new Object[0];
1861    
1862                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1863                                    finderArgs, this);
1864    
1865                    if (count == null) {
1866                            Session session = null;
1867    
1868                            try {
1869                                    session = openSession();
1870    
1871                                    Query q = session.createQuery(_SQL_COUNT_SHOPPINGORDER);
1872    
1873                                    count = (Long)q.uniqueResult();
1874                            }
1875                            catch (Exception e) {
1876                                    throw processException(e);
1877                            }
1878                            finally {
1879                                    if (count == null) {
1880                                            count = Long.valueOf(0);
1881                                    }
1882    
1883                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1884                                            count);
1885    
1886                                    closeSession(session);
1887                            }
1888                    }
1889    
1890                    return count.intValue();
1891            }
1892    
1893            public void afterPropertiesSet() {
1894                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1895                                            com.liferay.portal.util.PropsUtil.get(
1896                                                    "value.object.listener.com.liferay.portlet.shopping.model.ShoppingOrder")));
1897    
1898                    if (listenerClassNames.length > 0) {
1899                            try {
1900                                    List<ModelListener<ShoppingOrder>> listenersList = new ArrayList<ModelListener<ShoppingOrder>>();
1901    
1902                                    for (String listenerClassName : listenerClassNames) {
1903                                            listenersList.add((ModelListener<ShoppingOrder>)InstanceFactory.newInstance(
1904                                                            listenerClassName));
1905                                    }
1906    
1907                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1908                            }
1909                            catch (Exception e) {
1910                                    _log.error(e);
1911                            }
1912                    }
1913            }
1914    
1915            @BeanReference(type = ShoppingCartPersistence.class)
1916            protected ShoppingCartPersistence shoppingCartPersistence;
1917            @BeanReference(type = ShoppingCategoryPersistence.class)
1918            protected ShoppingCategoryPersistence shoppingCategoryPersistence;
1919            @BeanReference(type = ShoppingCouponPersistence.class)
1920            protected ShoppingCouponPersistence shoppingCouponPersistence;
1921            @BeanReference(type = ShoppingItemPersistence.class)
1922            protected ShoppingItemPersistence shoppingItemPersistence;
1923            @BeanReference(type = ShoppingItemFieldPersistence.class)
1924            protected ShoppingItemFieldPersistence shoppingItemFieldPersistence;
1925            @BeanReference(type = ShoppingItemPricePersistence.class)
1926            protected ShoppingItemPricePersistence shoppingItemPricePersistence;
1927            @BeanReference(type = ShoppingOrderPersistence.class)
1928            protected ShoppingOrderPersistence shoppingOrderPersistence;
1929            @BeanReference(type = ShoppingOrderItemPersistence.class)
1930            protected ShoppingOrderItemPersistence shoppingOrderItemPersistence;
1931            @BeanReference(type = CompanyPersistence.class)
1932            protected CompanyPersistence companyPersistence;
1933            @BeanReference(type = ResourcePersistence.class)
1934            protected ResourcePersistence resourcePersistence;
1935            @BeanReference(type = UserPersistence.class)
1936            protected UserPersistence userPersistence;
1937            @BeanReference(type = MBMessagePersistence.class)
1938            protected MBMessagePersistence mbMessagePersistence;
1939            private static final String _SQL_SELECT_SHOPPINGORDER = "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder";
1940            private static final String _SQL_SELECT_SHOPPINGORDER_WHERE = "SELECT shoppingOrder FROM ShoppingOrder shoppingOrder WHERE ";
1941            private static final String _SQL_COUNT_SHOPPINGORDER = "SELECT COUNT(shoppingOrder) FROM ShoppingOrder shoppingOrder";
1942            private static final String _SQL_COUNT_SHOPPINGORDER_WHERE = "SELECT COUNT(shoppingOrder) FROM ShoppingOrder shoppingOrder WHERE ";
1943            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "shoppingOrder.groupId = ?";
1944            private static final String _FINDER_COLUMN_NUMBER_NUMBER_1 = "shoppingOrder.number IS NULL";
1945            private static final String _FINDER_COLUMN_NUMBER_NUMBER_2 = "shoppingOrder.number = ?";
1946            private static final String _FINDER_COLUMN_NUMBER_NUMBER_3 = "(shoppingOrder.number IS NULL OR shoppingOrder.number = ?)";
1947            private static final String _FINDER_COLUMN_PPTXNID_PPTXNID_1 = "shoppingOrder.ppTxnId IS NULL";
1948            private static final String _FINDER_COLUMN_PPTXNID_PPTXNID_2 = "shoppingOrder.ppTxnId = ?";
1949            private static final String _FINDER_COLUMN_PPTXNID_PPTXNID_3 = "(shoppingOrder.ppTxnId IS NULL OR shoppingOrder.ppTxnId = ?)";
1950            private static final String _FINDER_COLUMN_G_U_PPPS_GROUPID_2 = "shoppingOrder.groupId = ? AND ";
1951            private static final String _FINDER_COLUMN_G_U_PPPS_USERID_2 = "shoppingOrder.userId = ? AND ";
1952            private static final String _FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_1 = "shoppingOrder.ppPaymentStatus IS NULL";
1953            private static final String _FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_2 = "shoppingOrder.ppPaymentStatus = ?";
1954            private static final String _FINDER_COLUMN_G_U_PPPS_PPPAYMENTSTATUS_3 = "(shoppingOrder.ppPaymentStatus IS NULL OR shoppingOrder.ppPaymentStatus = ?)";
1955            private static final String _FILTER_SQL_SELECT_SHOPPINGORDER_WHERE = "SELECT DISTINCT {shoppingOrder.*} FROM ShoppingOrder shoppingOrder WHERE ";
1956            private static final String _FILTER_SQL_COUNT_SHOPPINGORDER_WHERE = "SELECT COUNT(DISTINCT shoppingOrder.orderId) AS COUNT_VALUE FROM ShoppingOrder shoppingOrder WHERE ";
1957            private static final String _FILTER_COLUMN_PK = "shoppingOrder.orderId";
1958            private static final String _FILTER_COLUMN_USERID = "shoppingOrder.userId";
1959            private static final String _FILTER_ENTITY_ALIAS = "shoppingOrder";
1960            private static final String _ORDER_BY_ENTITY_ALIAS = "shoppingOrder.";
1961            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ShoppingOrder exists with the primary key ";
1962            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ShoppingOrder exists with the key {";
1963            private static Log _log = LogFactoryUtil.getLog(ShoppingOrderPersistenceImpl.class);
1964    }