0001: /**
0002: * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
0003: *
0004: * Permission is hereby granted, free of charge, to any person obtaining a copy
0005: * of this software and associated documentation files (the "Software"), to deal
0006: * in the Software without restriction, including without limitation the rights
0007: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
0008: * copies of the Software, and to permit persons to whom the Software is
0009: * furnished to do so, subject to the following conditions:
0010: *
0011: * The above copyright notice and this permission notice shall be included in
0012: * all copies or substantial portions of the Software.
0013: *
0014: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0015: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0016: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0017: * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0018: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0019: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
0020: * SOFTWARE.
0021: */package com.liferay.portlet.shopping.service.persistence;
0022:
0023: import com.liferay.portal.SystemException;
0024: import com.liferay.portal.kernel.dao.DynamicQuery;
0025: import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
0026: import com.liferay.portal.kernel.util.GetterUtil;
0027: import com.liferay.portal.kernel.util.OrderByComparator;
0028: import com.liferay.portal.kernel.util.StringMaker;
0029: import com.liferay.portal.kernel.util.StringPool;
0030: import com.liferay.portal.kernel.util.Validator;
0031: import com.liferay.portal.model.ModelListener;
0032: import com.liferay.portal.service.persistence.BasePersistence;
0033: import com.liferay.portal.spring.hibernate.FinderCache;
0034: import com.liferay.portal.spring.hibernate.HibernateUtil;
0035: import com.liferay.portal.util.PropsUtil;
0036:
0037: import com.liferay.portlet.shopping.NoSuchOrderException;
0038: import com.liferay.portlet.shopping.model.ShoppingOrder;
0039: import com.liferay.portlet.shopping.model.impl.ShoppingOrderImpl;
0040: import com.liferay.portlet.shopping.model.impl.ShoppingOrderModelImpl;
0041:
0042: import com.liferay.util.dao.hibernate.QueryUtil;
0043:
0044: import org.apache.commons.logging.Log;
0045: import org.apache.commons.logging.LogFactory;
0046:
0047: import org.hibernate.Query;
0048: import org.hibernate.Session;
0049:
0050: import java.util.Collections;
0051: import java.util.Iterator;
0052: import java.util.List;
0053:
0054: /**
0055: * <a href="ShoppingOrderPersistenceImpl.java.html"><b><i>View Source</i></b></a>
0056: *
0057: * @author Brian Wing Shun Chan
0058: *
0059: */
0060: public class ShoppingOrderPersistenceImpl extends BasePersistence
0061: implements ShoppingOrderPersistence {
0062: public ShoppingOrder create(long orderId) {
0063: ShoppingOrder shoppingOrder = new ShoppingOrderImpl();
0064:
0065: shoppingOrder.setNew(true);
0066: shoppingOrder.setPrimaryKey(orderId);
0067:
0068: return shoppingOrder;
0069: }
0070:
0071: public ShoppingOrder remove(long orderId)
0072: throws NoSuchOrderException, SystemException {
0073: Session session = null;
0074:
0075: try {
0076: session = openSession();
0077:
0078: ShoppingOrder shoppingOrder = (ShoppingOrder) session.get(
0079: ShoppingOrderImpl.class, new Long(orderId));
0080:
0081: if (shoppingOrder == null) {
0082: if (_log.isWarnEnabled()) {
0083: _log
0084: .warn("No ShoppingOrder exists with the primary key "
0085: + orderId);
0086: }
0087:
0088: throw new NoSuchOrderException(
0089: "No ShoppingOrder exists with the primary key "
0090: + orderId);
0091: }
0092:
0093: return remove(shoppingOrder);
0094: } catch (NoSuchOrderException nsee) {
0095: throw nsee;
0096: } catch (Exception e) {
0097: throw HibernateUtil.processException(e);
0098: } finally {
0099: closeSession(session);
0100: }
0101: }
0102:
0103: public ShoppingOrder remove(ShoppingOrder shoppingOrder)
0104: throws SystemException {
0105: ModelListener listener = _getListener();
0106:
0107: if (listener != null) {
0108: listener.onBeforeRemove(shoppingOrder);
0109: }
0110:
0111: shoppingOrder = removeImpl(shoppingOrder);
0112:
0113: if (listener != null) {
0114: listener.onAfterRemove(shoppingOrder);
0115: }
0116:
0117: return shoppingOrder;
0118: }
0119:
0120: protected ShoppingOrder removeImpl(ShoppingOrder shoppingOrder)
0121: throws SystemException {
0122: Session session = null;
0123:
0124: try {
0125: session = openSession();
0126:
0127: session.delete(shoppingOrder);
0128:
0129: session.flush();
0130:
0131: return shoppingOrder;
0132: } catch (Exception e) {
0133: throw HibernateUtil.processException(e);
0134: } finally {
0135: closeSession(session);
0136:
0137: FinderCache.clearCache(ShoppingOrder.class.getName());
0138: }
0139: }
0140:
0141: public ShoppingOrder update(ShoppingOrder shoppingOrder)
0142: throws SystemException {
0143: return update(shoppingOrder, false);
0144: }
0145:
0146: public ShoppingOrder update(ShoppingOrder shoppingOrder,
0147: boolean merge) throws SystemException {
0148: ModelListener listener = _getListener();
0149:
0150: boolean isNew = shoppingOrder.isNew();
0151:
0152: if (listener != null) {
0153: if (isNew) {
0154: listener.onBeforeCreate(shoppingOrder);
0155: } else {
0156: listener.onBeforeUpdate(shoppingOrder);
0157: }
0158: }
0159:
0160: shoppingOrder = updateImpl(shoppingOrder, merge);
0161:
0162: if (listener != null) {
0163: if (isNew) {
0164: listener.onAfterCreate(shoppingOrder);
0165: } else {
0166: listener.onAfterUpdate(shoppingOrder);
0167: }
0168: }
0169:
0170: return shoppingOrder;
0171: }
0172:
0173: public ShoppingOrder updateImpl(
0174: com.liferay.portlet.shopping.model.ShoppingOrder shoppingOrder,
0175: boolean merge) throws SystemException {
0176: Session session = null;
0177:
0178: try {
0179: session = openSession();
0180:
0181: if (merge) {
0182: session.merge(shoppingOrder);
0183: } else {
0184: if (shoppingOrder.isNew()) {
0185: session.save(shoppingOrder);
0186: }
0187: }
0188:
0189: session.flush();
0190:
0191: shoppingOrder.setNew(false);
0192:
0193: return shoppingOrder;
0194: } catch (Exception e) {
0195: throw HibernateUtil.processException(e);
0196: } finally {
0197: closeSession(session);
0198:
0199: FinderCache.clearCache(ShoppingOrder.class.getName());
0200: }
0201: }
0202:
0203: public ShoppingOrder findByPrimaryKey(long orderId)
0204: throws NoSuchOrderException, SystemException {
0205: ShoppingOrder shoppingOrder = fetchByPrimaryKey(orderId);
0206:
0207: if (shoppingOrder == null) {
0208: if (_log.isWarnEnabled()) {
0209: _log
0210: .warn("No ShoppingOrder exists with the primary key "
0211: + orderId);
0212: }
0213:
0214: throw new NoSuchOrderException(
0215: "No ShoppingOrder exists with the primary key "
0216: + orderId);
0217: }
0218:
0219: return shoppingOrder;
0220: }
0221:
0222: public ShoppingOrder fetchByPrimaryKey(long orderId)
0223: throws SystemException {
0224: Session session = null;
0225:
0226: try {
0227: session = openSession();
0228:
0229: return (ShoppingOrder) session.get(ShoppingOrderImpl.class,
0230: new Long(orderId));
0231: } catch (Exception e) {
0232: throw HibernateUtil.processException(e);
0233: } finally {
0234: closeSession(session);
0235: }
0236: }
0237:
0238: public List findByGroupId(long groupId) throws SystemException {
0239: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
0240: String finderClassName = ShoppingOrder.class.getName();
0241: String finderMethodName = "findByGroupId";
0242: String[] finderParams = new String[] { Long.class.getName() };
0243: Object[] finderArgs = new Object[] { new Long(groupId) };
0244:
0245: Object result = null;
0246:
0247: if (finderClassNameCacheEnabled) {
0248: result = FinderCache.getResult(finderClassName,
0249: finderMethodName, finderParams, finderArgs,
0250: getSessionFactory());
0251: }
0252:
0253: if (result == null) {
0254: Session session = null;
0255:
0256: try {
0257: session = openSession();
0258:
0259: StringMaker query = new StringMaker();
0260:
0261: query
0262: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0263:
0264: query.append("groupId = ?");
0265:
0266: query.append(" ");
0267:
0268: query.append("ORDER BY ");
0269:
0270: query.append("createDate DESC");
0271:
0272: Query q = session.createQuery(query.toString());
0273:
0274: int queryPos = 0;
0275:
0276: q.setLong(queryPos++, groupId);
0277:
0278: List list = q.list();
0279:
0280: FinderCache.putResult(finderClassNameCacheEnabled,
0281: finderClassName, finderMethodName,
0282: finderParams, finderArgs, list);
0283:
0284: return list;
0285: } catch (Exception e) {
0286: throw HibernateUtil.processException(e);
0287: } finally {
0288: closeSession(session);
0289: }
0290: } else {
0291: return (List) result;
0292: }
0293: }
0294:
0295: public List findByGroupId(long groupId, int begin, int end)
0296: throws SystemException {
0297: return findByGroupId(groupId, begin, end, null);
0298: }
0299:
0300: public List findByGroupId(long groupId, int begin, int end,
0301: OrderByComparator obc) throws SystemException {
0302: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
0303: String finderClassName = ShoppingOrder.class.getName();
0304: String finderMethodName = "findByGroupId";
0305: String[] finderParams = new String[] { Long.class.getName(),
0306:
0307: "java.lang.Integer", "java.lang.Integer",
0308: "com.liferay.portal.kernel.util.OrderByComparator" };
0309: Object[] finderArgs = new Object[] { new Long(groupId),
0310:
0311: String.valueOf(begin), String.valueOf(end), String.valueOf(obc) };
0312:
0313: Object result = null;
0314:
0315: if (finderClassNameCacheEnabled) {
0316: result = FinderCache.getResult(finderClassName,
0317: finderMethodName, finderParams, finderArgs,
0318: getSessionFactory());
0319: }
0320:
0321: if (result == null) {
0322: Session session = null;
0323:
0324: try {
0325: session = openSession();
0326:
0327: StringMaker query = new StringMaker();
0328:
0329: query
0330: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0331:
0332: query.append("groupId = ?");
0333:
0334: query.append(" ");
0335:
0336: if (obc != null) {
0337: query.append("ORDER BY ");
0338: query.append(obc.getOrderBy());
0339: }
0340:
0341: else {
0342: query.append("ORDER BY ");
0343:
0344: query.append("createDate DESC");
0345: }
0346:
0347: Query q = session.createQuery(query.toString());
0348:
0349: int queryPos = 0;
0350:
0351: q.setLong(queryPos++, groupId);
0352:
0353: List list = QueryUtil.list(q, getDialect(), begin, end);
0354:
0355: FinderCache.putResult(finderClassNameCacheEnabled,
0356: finderClassName, finderMethodName,
0357: finderParams, finderArgs, list);
0358:
0359: return list;
0360: } catch (Exception e) {
0361: throw HibernateUtil.processException(e);
0362: } finally {
0363: closeSession(session);
0364: }
0365: } else {
0366: return (List) result;
0367: }
0368: }
0369:
0370: public ShoppingOrder findByGroupId_First(long groupId,
0371: OrderByComparator obc) throws NoSuchOrderException,
0372: SystemException {
0373: List list = findByGroupId(groupId, 0, 1, obc);
0374:
0375: if (list.size() == 0) {
0376: StringMaker msg = new StringMaker();
0377:
0378: msg.append("No ShoppingOrder exists with the key {");
0379:
0380: msg.append("groupId=" + groupId);
0381:
0382: msg.append(StringPool.CLOSE_CURLY_BRACE);
0383:
0384: throw new NoSuchOrderException(msg.toString());
0385: } else {
0386: return (ShoppingOrder) list.get(0);
0387: }
0388: }
0389:
0390: public ShoppingOrder findByGroupId_Last(long groupId,
0391: OrderByComparator obc) throws NoSuchOrderException,
0392: SystemException {
0393: int count = countByGroupId(groupId);
0394:
0395: List list = findByGroupId(groupId, count - 1, count, obc);
0396:
0397: if (list.size() == 0) {
0398: StringMaker msg = new StringMaker();
0399:
0400: msg.append("No ShoppingOrder exists with the key {");
0401:
0402: msg.append("groupId=" + groupId);
0403:
0404: msg.append(StringPool.CLOSE_CURLY_BRACE);
0405:
0406: throw new NoSuchOrderException(msg.toString());
0407: } else {
0408: return (ShoppingOrder) list.get(0);
0409: }
0410: }
0411:
0412: public ShoppingOrder[] findByGroupId_PrevAndNext(long orderId,
0413: long groupId, OrderByComparator obc)
0414: throws NoSuchOrderException, SystemException {
0415: ShoppingOrder shoppingOrder = findByPrimaryKey(orderId);
0416:
0417: int count = countByGroupId(groupId);
0418:
0419: Session session = null;
0420:
0421: try {
0422: session = openSession();
0423:
0424: StringMaker query = new StringMaker();
0425:
0426: query
0427: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0428:
0429: query.append("groupId = ?");
0430:
0431: query.append(" ");
0432:
0433: if (obc != null) {
0434: query.append("ORDER BY ");
0435: query.append(obc.getOrderBy());
0436: }
0437:
0438: else {
0439: query.append("ORDER BY ");
0440:
0441: query.append("createDate DESC");
0442: }
0443:
0444: Query q = session.createQuery(query.toString());
0445:
0446: int queryPos = 0;
0447:
0448: q.setLong(queryPos++, groupId);
0449:
0450: Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
0451: shoppingOrder);
0452:
0453: ShoppingOrder[] array = new ShoppingOrderImpl[3];
0454:
0455: array[0] = (ShoppingOrder) objArray[0];
0456: array[1] = (ShoppingOrder) objArray[1];
0457: array[2] = (ShoppingOrder) objArray[2];
0458:
0459: return array;
0460: } catch (Exception e) {
0461: throw HibernateUtil.processException(e);
0462: } finally {
0463: closeSession(session);
0464: }
0465: }
0466:
0467: public ShoppingOrder findByNumber(String number)
0468: throws NoSuchOrderException, SystemException {
0469: ShoppingOrder shoppingOrder = fetchByNumber(number);
0470:
0471: if (shoppingOrder == null) {
0472: StringMaker msg = new StringMaker();
0473:
0474: msg.append("No ShoppingOrder exists with the key {");
0475:
0476: msg.append("number=" + number);
0477:
0478: msg.append(StringPool.CLOSE_CURLY_BRACE);
0479:
0480: if (_log.isWarnEnabled()) {
0481: _log.warn(msg.toString());
0482: }
0483:
0484: throw new NoSuchOrderException(msg.toString());
0485: }
0486:
0487: return shoppingOrder;
0488: }
0489:
0490: public ShoppingOrder fetchByNumber(String number)
0491: throws SystemException {
0492: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
0493: String finderClassName = ShoppingOrder.class.getName();
0494: String finderMethodName = "fetchByNumber";
0495: String[] finderParams = new String[] { String.class.getName() };
0496: Object[] finderArgs = new Object[] { number };
0497:
0498: Object result = null;
0499:
0500: if (finderClassNameCacheEnabled) {
0501: result = FinderCache.getResult(finderClassName,
0502: finderMethodName, finderParams, finderArgs,
0503: getSessionFactory());
0504: }
0505:
0506: if (result == null) {
0507: Session session = null;
0508:
0509: try {
0510: session = openSession();
0511:
0512: StringMaker query = new StringMaker();
0513:
0514: query
0515: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0516:
0517: if (number == null) {
0518: query.append("number_ IS NULL");
0519: } else {
0520: query.append("number_ = ?");
0521: }
0522:
0523: query.append(" ");
0524:
0525: query.append("ORDER BY ");
0526:
0527: query.append("createDate DESC");
0528:
0529: Query q = session.createQuery(query.toString());
0530:
0531: int queryPos = 0;
0532:
0533: if (number != null) {
0534: q.setString(queryPos++, number);
0535: }
0536:
0537: List list = q.list();
0538:
0539: FinderCache.putResult(finderClassNameCacheEnabled,
0540: finderClassName, finderMethodName,
0541: finderParams, finderArgs, list);
0542:
0543: if (list.size() == 0) {
0544: return null;
0545: } else {
0546: return (ShoppingOrder) list.get(0);
0547: }
0548: } catch (Exception e) {
0549: throw HibernateUtil.processException(e);
0550: } finally {
0551: closeSession(session);
0552: }
0553: } else {
0554: List list = (List) result;
0555:
0556: if (list.size() == 0) {
0557: return null;
0558: } else {
0559: return (ShoppingOrder) list.get(0);
0560: }
0561: }
0562: }
0563:
0564: public List findByG_U_PPPS(long groupId, long userId,
0565: String ppPaymentStatus) throws SystemException {
0566: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
0567: String finderClassName = ShoppingOrder.class.getName();
0568: String finderMethodName = "findByG_U_PPPS";
0569: String[] finderParams = new String[] { Long.class.getName(),
0570: Long.class.getName(), String.class.getName() };
0571: Object[] finderArgs = new Object[] { new Long(groupId),
0572: new Long(userId),
0573:
0574: ppPaymentStatus };
0575:
0576: Object result = null;
0577:
0578: if (finderClassNameCacheEnabled) {
0579: result = FinderCache.getResult(finderClassName,
0580: finderMethodName, finderParams, finderArgs,
0581: getSessionFactory());
0582: }
0583:
0584: if (result == null) {
0585: Session session = null;
0586:
0587: try {
0588: session = openSession();
0589:
0590: StringMaker query = new StringMaker();
0591:
0592: query
0593: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0594:
0595: query.append("groupId = ?");
0596:
0597: query.append(" AND ");
0598:
0599: query.append("userId = ?");
0600:
0601: query.append(" AND ");
0602:
0603: if (ppPaymentStatus == null) {
0604: query.append("ppPaymentStatus IS NULL");
0605: } else {
0606: query.append("ppPaymentStatus = ?");
0607: }
0608:
0609: query.append(" ");
0610:
0611: query.append("ORDER BY ");
0612:
0613: query.append("createDate DESC");
0614:
0615: Query q = session.createQuery(query.toString());
0616:
0617: int queryPos = 0;
0618:
0619: q.setLong(queryPos++, groupId);
0620:
0621: q.setLong(queryPos++, userId);
0622:
0623: if (ppPaymentStatus != null) {
0624: q.setString(queryPos++, ppPaymentStatus);
0625: }
0626:
0627: List list = q.list();
0628:
0629: FinderCache.putResult(finderClassNameCacheEnabled,
0630: finderClassName, finderMethodName,
0631: finderParams, finderArgs, list);
0632:
0633: return list;
0634: } catch (Exception e) {
0635: throw HibernateUtil.processException(e);
0636: } finally {
0637: closeSession(session);
0638: }
0639: } else {
0640: return (List) result;
0641: }
0642: }
0643:
0644: public List findByG_U_PPPS(long groupId, long userId,
0645: String ppPaymentStatus, int begin, int end)
0646: throws SystemException {
0647: return findByG_U_PPPS(groupId, userId, ppPaymentStatus, begin,
0648: end, null);
0649: }
0650:
0651: public List findByG_U_PPPS(long groupId, long userId,
0652: String ppPaymentStatus, int begin, int end,
0653: OrderByComparator obc) throws SystemException {
0654: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
0655: String finderClassName = ShoppingOrder.class.getName();
0656: String finderMethodName = "findByG_U_PPPS";
0657: String[] finderParams = new String[] { Long.class.getName(),
0658: Long.class.getName(), String.class.getName(),
0659:
0660: "java.lang.Integer", "java.lang.Integer",
0661: "com.liferay.portal.kernel.util.OrderByComparator" };
0662: Object[] finderArgs = new Object[] { new Long(groupId),
0663: new Long(userId),
0664:
0665: ppPaymentStatus,
0666:
0667: String.valueOf(begin), String.valueOf(end),
0668: String.valueOf(obc) };
0669:
0670: Object result = null;
0671:
0672: if (finderClassNameCacheEnabled) {
0673: result = FinderCache.getResult(finderClassName,
0674: finderMethodName, finderParams, finderArgs,
0675: getSessionFactory());
0676: }
0677:
0678: if (result == null) {
0679: Session session = null;
0680:
0681: try {
0682: session = openSession();
0683:
0684: StringMaker query = new StringMaker();
0685:
0686: query
0687: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0688:
0689: query.append("groupId = ?");
0690:
0691: query.append(" AND ");
0692:
0693: query.append("userId = ?");
0694:
0695: query.append(" AND ");
0696:
0697: if (ppPaymentStatus == null) {
0698: query.append("ppPaymentStatus IS NULL");
0699: } else {
0700: query.append("ppPaymentStatus = ?");
0701: }
0702:
0703: query.append(" ");
0704:
0705: if (obc != null) {
0706: query.append("ORDER BY ");
0707: query.append(obc.getOrderBy());
0708: }
0709:
0710: else {
0711: query.append("ORDER BY ");
0712:
0713: query.append("createDate DESC");
0714: }
0715:
0716: Query q = session.createQuery(query.toString());
0717:
0718: int queryPos = 0;
0719:
0720: q.setLong(queryPos++, groupId);
0721:
0722: q.setLong(queryPos++, userId);
0723:
0724: if (ppPaymentStatus != null) {
0725: q.setString(queryPos++, ppPaymentStatus);
0726: }
0727:
0728: List list = QueryUtil.list(q, getDialect(), begin, end);
0729:
0730: FinderCache.putResult(finderClassNameCacheEnabled,
0731: finderClassName, finderMethodName,
0732: finderParams, finderArgs, list);
0733:
0734: return list;
0735: } catch (Exception e) {
0736: throw HibernateUtil.processException(e);
0737: } finally {
0738: closeSession(session);
0739: }
0740: } else {
0741: return (List) result;
0742: }
0743: }
0744:
0745: public ShoppingOrder findByG_U_PPPS_First(long groupId,
0746: long userId, String ppPaymentStatus, OrderByComparator obc)
0747: throws NoSuchOrderException, SystemException {
0748: List list = findByG_U_PPPS(groupId, userId, ppPaymentStatus, 0,
0749: 1, obc);
0750:
0751: if (list.size() == 0) {
0752: StringMaker msg = new StringMaker();
0753:
0754: msg.append("No ShoppingOrder exists with the key {");
0755:
0756: msg.append("groupId=" + groupId);
0757:
0758: msg.append(", ");
0759: msg.append("userId=" + userId);
0760:
0761: msg.append(", ");
0762: msg.append("ppPaymentStatus=" + ppPaymentStatus);
0763:
0764: msg.append(StringPool.CLOSE_CURLY_BRACE);
0765:
0766: throw new NoSuchOrderException(msg.toString());
0767: } else {
0768: return (ShoppingOrder) list.get(0);
0769: }
0770: }
0771:
0772: public ShoppingOrder findByG_U_PPPS_Last(long groupId, long userId,
0773: String ppPaymentStatus, OrderByComparator obc)
0774: throws NoSuchOrderException, SystemException {
0775: int count = countByG_U_PPPS(groupId, userId, ppPaymentStatus);
0776:
0777: List list = findByG_U_PPPS(groupId, userId, ppPaymentStatus,
0778: count - 1, count, obc);
0779:
0780: if (list.size() == 0) {
0781: StringMaker msg = new StringMaker();
0782:
0783: msg.append("No ShoppingOrder exists with the key {");
0784:
0785: msg.append("groupId=" + groupId);
0786:
0787: msg.append(", ");
0788: msg.append("userId=" + userId);
0789:
0790: msg.append(", ");
0791: msg.append("ppPaymentStatus=" + ppPaymentStatus);
0792:
0793: msg.append(StringPool.CLOSE_CURLY_BRACE);
0794:
0795: throw new NoSuchOrderException(msg.toString());
0796: } else {
0797: return (ShoppingOrder) list.get(0);
0798: }
0799: }
0800:
0801: public ShoppingOrder[] findByG_U_PPPS_PrevAndNext(long orderId,
0802: long groupId, long userId, String ppPaymentStatus,
0803: OrderByComparator obc) throws NoSuchOrderException,
0804: SystemException {
0805: ShoppingOrder shoppingOrder = findByPrimaryKey(orderId);
0806:
0807: int count = countByG_U_PPPS(groupId, userId, ppPaymentStatus);
0808:
0809: Session session = null;
0810:
0811: try {
0812: session = openSession();
0813:
0814: StringMaker query = new StringMaker();
0815:
0816: query
0817: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
0818:
0819: query.append("groupId = ?");
0820:
0821: query.append(" AND ");
0822:
0823: query.append("userId = ?");
0824:
0825: query.append(" AND ");
0826:
0827: if (ppPaymentStatus == null) {
0828: query.append("ppPaymentStatus IS NULL");
0829: } else {
0830: query.append("ppPaymentStatus = ?");
0831: }
0832:
0833: query.append(" ");
0834:
0835: if (obc != null) {
0836: query.append("ORDER BY ");
0837: query.append(obc.getOrderBy());
0838: }
0839:
0840: else {
0841: query.append("ORDER BY ");
0842:
0843: query.append("createDate DESC");
0844: }
0845:
0846: Query q = session.createQuery(query.toString());
0847:
0848: int queryPos = 0;
0849:
0850: q.setLong(queryPos++, groupId);
0851:
0852: q.setLong(queryPos++, userId);
0853:
0854: if (ppPaymentStatus != null) {
0855: q.setString(queryPos++, ppPaymentStatus);
0856: }
0857:
0858: Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
0859: shoppingOrder);
0860:
0861: ShoppingOrder[] array = new ShoppingOrderImpl[3];
0862:
0863: array[0] = (ShoppingOrder) objArray[0];
0864: array[1] = (ShoppingOrder) objArray[1];
0865: array[2] = (ShoppingOrder) objArray[2];
0866:
0867: return array;
0868: } catch (Exception e) {
0869: throw HibernateUtil.processException(e);
0870: } finally {
0871: closeSession(session);
0872: }
0873: }
0874:
0875: public List findWithDynamicQuery(
0876: DynamicQueryInitializer queryInitializer)
0877: throws SystemException {
0878: Session session = null;
0879:
0880: try {
0881: session = openSession();
0882:
0883: DynamicQuery query = queryInitializer.initialize(session);
0884:
0885: return query.list();
0886: } catch (Exception e) {
0887: throw HibernateUtil.processException(e);
0888: } finally {
0889: closeSession(session);
0890: }
0891: }
0892:
0893: public List findWithDynamicQuery(
0894: DynamicQueryInitializer queryInitializer, int begin, int end)
0895: throws SystemException {
0896: Session session = null;
0897:
0898: try {
0899: session = openSession();
0900:
0901: DynamicQuery query = queryInitializer.initialize(session);
0902:
0903: query.setLimit(begin, end);
0904:
0905: return query.list();
0906: } catch (Exception e) {
0907: throw HibernateUtil.processException(e);
0908: } finally {
0909: closeSession(session);
0910: }
0911: }
0912:
0913: public List findAll() throws SystemException {
0914: return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
0915: }
0916:
0917: public List findAll(int begin, int end) throws SystemException {
0918: return findAll(begin, end, null);
0919: }
0920:
0921: public List findAll(int begin, int end, OrderByComparator obc)
0922: throws SystemException {
0923: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
0924: String finderClassName = ShoppingOrder.class.getName();
0925: String finderMethodName = "findAll";
0926: String[] finderParams = new String[] { "java.lang.Integer",
0927: "java.lang.Integer",
0928: "com.liferay.portal.kernel.util.OrderByComparator" };
0929: Object[] finderArgs = new Object[] { String.valueOf(begin),
0930: String.valueOf(end), String.valueOf(obc) };
0931:
0932: Object result = null;
0933:
0934: if (finderClassNameCacheEnabled) {
0935: result = FinderCache.getResult(finderClassName,
0936: finderMethodName, finderParams, finderArgs,
0937: getSessionFactory());
0938: }
0939:
0940: if (result == null) {
0941: Session session = null;
0942:
0943: try {
0944: session = openSession();
0945:
0946: StringMaker query = new StringMaker();
0947:
0948: query
0949: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder ");
0950:
0951: if (obc != null) {
0952: query.append("ORDER BY ");
0953: query.append(obc.getOrderBy());
0954: }
0955:
0956: else {
0957: query.append("ORDER BY ");
0958:
0959: query.append("createDate DESC");
0960: }
0961:
0962: Query q = session.createQuery(query.toString());
0963:
0964: List list = QueryUtil.list(q, getDialect(), begin, end);
0965:
0966: if (obc == null) {
0967: Collections.sort(list);
0968: }
0969:
0970: FinderCache.putResult(finderClassNameCacheEnabled,
0971: finderClassName, finderMethodName,
0972: finderParams, finderArgs, list);
0973:
0974: return list;
0975: } catch (Exception e) {
0976: throw HibernateUtil.processException(e);
0977: } finally {
0978: closeSession(session);
0979: }
0980: } else {
0981: return (List) result;
0982: }
0983: }
0984:
0985: public void removeByGroupId(long groupId) throws SystemException {
0986: Iterator itr = findByGroupId(groupId).iterator();
0987:
0988: while (itr.hasNext()) {
0989: ShoppingOrder shoppingOrder = (ShoppingOrder) itr.next();
0990:
0991: remove(shoppingOrder);
0992: }
0993: }
0994:
0995: public void removeByNumber(String number)
0996: throws NoSuchOrderException, SystemException {
0997: ShoppingOrder shoppingOrder = findByNumber(number);
0998:
0999: remove(shoppingOrder);
1000: }
1001:
1002: public void removeByG_U_PPPS(long groupId, long userId,
1003: String ppPaymentStatus) throws SystemException {
1004: Iterator itr = findByG_U_PPPS(groupId, userId, ppPaymentStatus)
1005: .iterator();
1006:
1007: while (itr.hasNext()) {
1008: ShoppingOrder shoppingOrder = (ShoppingOrder) itr.next();
1009:
1010: remove(shoppingOrder);
1011: }
1012: }
1013:
1014: public void removeAll() throws SystemException {
1015: Iterator itr = findAll().iterator();
1016:
1017: while (itr.hasNext()) {
1018: remove((ShoppingOrder) itr.next());
1019: }
1020: }
1021:
1022: public int countByGroupId(long groupId) throws SystemException {
1023: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
1024: String finderClassName = ShoppingOrder.class.getName();
1025: String finderMethodName = "countByGroupId";
1026: String[] finderParams = new String[] { Long.class.getName() };
1027: Object[] finderArgs = new Object[] { new Long(groupId) };
1028:
1029: Object result = null;
1030:
1031: if (finderClassNameCacheEnabled) {
1032: result = FinderCache.getResult(finderClassName,
1033: finderMethodName, finderParams, finderArgs,
1034: getSessionFactory());
1035: }
1036:
1037: if (result == null) {
1038: Session session = null;
1039:
1040: try {
1041: session = openSession();
1042:
1043: StringMaker query = new StringMaker();
1044:
1045: query.append("SELECT COUNT(*) ");
1046: query
1047: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
1048:
1049: query.append("groupId = ?");
1050:
1051: query.append(" ");
1052:
1053: Query q = session.createQuery(query.toString());
1054:
1055: int queryPos = 0;
1056:
1057: q.setLong(queryPos++, groupId);
1058:
1059: Long count = null;
1060:
1061: Iterator itr = q.list().iterator();
1062:
1063: if (itr.hasNext()) {
1064: count = (Long) itr.next();
1065: }
1066:
1067: if (count == null) {
1068: count = new Long(0);
1069: }
1070:
1071: FinderCache.putResult(finderClassNameCacheEnabled,
1072: finderClassName, finderMethodName,
1073: finderParams, finderArgs, count);
1074:
1075: return count.intValue();
1076: } catch (Exception e) {
1077: throw HibernateUtil.processException(e);
1078: } finally {
1079: closeSession(session);
1080: }
1081: } else {
1082: return ((Long) result).intValue();
1083: }
1084: }
1085:
1086: public int countByNumber(String number) throws SystemException {
1087: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
1088: String finderClassName = ShoppingOrder.class.getName();
1089: String finderMethodName = "countByNumber";
1090: String[] finderParams = new String[] { String.class.getName() };
1091: Object[] finderArgs = new Object[] { number };
1092:
1093: Object result = null;
1094:
1095: if (finderClassNameCacheEnabled) {
1096: result = FinderCache.getResult(finderClassName,
1097: finderMethodName, finderParams, finderArgs,
1098: getSessionFactory());
1099: }
1100:
1101: if (result == null) {
1102: Session session = null;
1103:
1104: try {
1105: session = openSession();
1106:
1107: StringMaker query = new StringMaker();
1108:
1109: query.append("SELECT COUNT(*) ");
1110: query
1111: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
1112:
1113: if (number == null) {
1114: query.append("number_ IS NULL");
1115: } else {
1116: query.append("number_ = ?");
1117: }
1118:
1119: query.append(" ");
1120:
1121: Query q = session.createQuery(query.toString());
1122:
1123: int queryPos = 0;
1124:
1125: if (number != null) {
1126: q.setString(queryPos++, number);
1127: }
1128:
1129: Long count = null;
1130:
1131: Iterator itr = q.list().iterator();
1132:
1133: if (itr.hasNext()) {
1134: count = (Long) itr.next();
1135: }
1136:
1137: if (count == null) {
1138: count = new Long(0);
1139: }
1140:
1141: FinderCache.putResult(finderClassNameCacheEnabled,
1142: finderClassName, finderMethodName,
1143: finderParams, finderArgs, count);
1144:
1145: return count.intValue();
1146: } catch (Exception e) {
1147: throw HibernateUtil.processException(e);
1148: } finally {
1149: closeSession(session);
1150: }
1151: } else {
1152: return ((Long) result).intValue();
1153: }
1154: }
1155:
1156: public int countByG_U_PPPS(long groupId, long userId,
1157: String ppPaymentStatus) throws SystemException {
1158: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
1159: String finderClassName = ShoppingOrder.class.getName();
1160: String finderMethodName = "countByG_U_PPPS";
1161: String[] finderParams = new String[] { Long.class.getName(),
1162: Long.class.getName(), String.class.getName() };
1163: Object[] finderArgs = new Object[] { new Long(groupId),
1164: new Long(userId),
1165:
1166: ppPaymentStatus };
1167:
1168: Object result = null;
1169:
1170: if (finderClassNameCacheEnabled) {
1171: result = FinderCache.getResult(finderClassName,
1172: finderMethodName, finderParams, finderArgs,
1173: getSessionFactory());
1174: }
1175:
1176: if (result == null) {
1177: Session session = null;
1178:
1179: try {
1180: session = openSession();
1181:
1182: StringMaker query = new StringMaker();
1183:
1184: query.append("SELECT COUNT(*) ");
1185: query
1186: .append("FROM com.liferay.portlet.shopping.model.ShoppingOrder WHERE ");
1187:
1188: query.append("groupId = ?");
1189:
1190: query.append(" AND ");
1191:
1192: query.append("userId = ?");
1193:
1194: query.append(" AND ");
1195:
1196: if (ppPaymentStatus == null) {
1197: query.append("ppPaymentStatus IS NULL");
1198: } else {
1199: query.append("ppPaymentStatus = ?");
1200: }
1201:
1202: query.append(" ");
1203:
1204: Query q = session.createQuery(query.toString());
1205:
1206: int queryPos = 0;
1207:
1208: q.setLong(queryPos++, groupId);
1209:
1210: q.setLong(queryPos++, userId);
1211:
1212: if (ppPaymentStatus != null) {
1213: q.setString(queryPos++, ppPaymentStatus);
1214: }
1215:
1216: Long count = null;
1217:
1218: Iterator itr = q.list().iterator();
1219:
1220: if (itr.hasNext()) {
1221: count = (Long) itr.next();
1222: }
1223:
1224: if (count == null) {
1225: count = new Long(0);
1226: }
1227:
1228: FinderCache.putResult(finderClassNameCacheEnabled,
1229: finderClassName, finderMethodName,
1230: finderParams, finderArgs, count);
1231:
1232: return count.intValue();
1233: } catch (Exception e) {
1234: throw HibernateUtil.processException(e);
1235: } finally {
1236: closeSession(session);
1237: }
1238: } else {
1239: return ((Long) result).intValue();
1240: }
1241: }
1242:
1243: public int countAll() throws SystemException {
1244: boolean finderClassNameCacheEnabled = ShoppingOrderModelImpl.CACHE_ENABLED;
1245: String finderClassName = ShoppingOrder.class.getName();
1246: String finderMethodName = "countAll";
1247: String[] finderParams = new String[] {};
1248: Object[] finderArgs = new Object[] {};
1249:
1250: Object result = null;
1251:
1252: if (finderClassNameCacheEnabled) {
1253: result = FinderCache.getResult(finderClassName,
1254: finderMethodName, finderParams, finderArgs,
1255: getSessionFactory());
1256: }
1257:
1258: if (result == null) {
1259: Session session = null;
1260:
1261: try {
1262: session = openSession();
1263:
1264: Query q = session
1265: .createQuery("SELECT COUNT(*) FROM com.liferay.portlet.shopping.model.ShoppingOrder");
1266:
1267: Long count = null;
1268:
1269: Iterator itr = q.list().iterator();
1270:
1271: if (itr.hasNext()) {
1272: count = (Long) itr.next();
1273: }
1274:
1275: if (count == null) {
1276: count = new Long(0);
1277: }
1278:
1279: FinderCache.putResult(finderClassNameCacheEnabled,
1280: finderClassName, finderMethodName,
1281: finderParams, finderArgs, count);
1282:
1283: return count.intValue();
1284: } catch (Exception e) {
1285: throw HibernateUtil.processException(e);
1286: } finally {
1287: closeSession(session);
1288: }
1289: } else {
1290: return ((Long) result).intValue();
1291: }
1292: }
1293:
1294: protected void initDao() {
1295: }
1296:
1297: private static ModelListener _getListener() {
1298: if (Validator.isNotNull(_LISTENER)) {
1299: try {
1300: return (ModelListener) Class.forName(_LISTENER)
1301: .newInstance();
1302: } catch (Exception e) {
1303: _log.error(e);
1304: }
1305: }
1306:
1307: return null;
1308: }
1309:
1310: private static final String _LISTENER = GetterUtil
1311: .getString(PropsUtil
1312: .get("value.object.listener.com.liferay.portlet.shopping.model.ShoppingOrder"));
1313: private static Log _log = LogFactory
1314: .getLog(ShoppingOrderPersistenceImpl.class);
1315: }
|