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.softwarecatalog.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.softwarecatalog.NoSuchFrameworkVersionException;
0038: import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion;
0039: import com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionImpl;
0040: import com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl;
0041:
0042: import com.liferay.util.dao.hibernate.QueryPos;
0043: import com.liferay.util.dao.hibernate.QueryUtil;
0044:
0045: import org.apache.commons.logging.Log;
0046: import org.apache.commons.logging.LogFactory;
0047:
0048: import org.hibernate.Hibernate;
0049: import org.hibernate.Query;
0050: import org.hibernate.SQLQuery;
0051: import org.hibernate.Session;
0052:
0053: import org.springframework.dao.DataAccessException;
0054:
0055: import org.springframework.jdbc.core.SqlParameter;
0056: import org.springframework.jdbc.object.MappingSqlQuery;
0057: import org.springframework.jdbc.object.SqlUpdate;
0058:
0059: import java.sql.ResultSet;
0060: import java.sql.SQLException;
0061: import java.sql.Types;
0062:
0063: import java.util.Collections;
0064: import java.util.Iterator;
0065: import java.util.List;
0066:
0067: /**
0068: * <a href="SCFrameworkVersionPersistenceImpl.java.html"><b><i>View Source</i></b></a>
0069: *
0070: * @author Brian Wing Shun Chan
0071: *
0072: */
0073: public class SCFrameworkVersionPersistenceImpl extends BasePersistence
0074: implements SCFrameworkVersionPersistence {
0075: public SCFrameworkVersion create(long frameworkVersionId) {
0076: SCFrameworkVersion scFrameworkVersion = new SCFrameworkVersionImpl();
0077:
0078: scFrameworkVersion.setNew(true);
0079: scFrameworkVersion.setPrimaryKey(frameworkVersionId);
0080:
0081: return scFrameworkVersion;
0082: }
0083:
0084: public SCFrameworkVersion remove(long frameworkVersionId)
0085: throws NoSuchFrameworkVersionException, SystemException {
0086: Session session = null;
0087:
0088: try {
0089: session = openSession();
0090:
0091: SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion) session
0092: .get(SCFrameworkVersionImpl.class, new Long(
0093: frameworkVersionId));
0094:
0095: if (scFrameworkVersion == null) {
0096: if (_log.isWarnEnabled()) {
0097: _log
0098: .warn("No SCFrameworkVersion exists with the primary key "
0099: + frameworkVersionId);
0100: }
0101:
0102: throw new NoSuchFrameworkVersionException(
0103: "No SCFrameworkVersion exists with the primary key "
0104: + frameworkVersionId);
0105: }
0106:
0107: return remove(scFrameworkVersion);
0108: } catch (NoSuchFrameworkVersionException nsee) {
0109: throw nsee;
0110: } catch (Exception e) {
0111: throw HibernateUtil.processException(e);
0112: } finally {
0113: closeSession(session);
0114: }
0115: }
0116:
0117: public SCFrameworkVersion remove(
0118: SCFrameworkVersion scFrameworkVersion)
0119: throws SystemException {
0120: ModelListener listener = _getListener();
0121:
0122: if (listener != null) {
0123: listener.onBeforeRemove(scFrameworkVersion);
0124: }
0125:
0126: scFrameworkVersion = removeImpl(scFrameworkVersion);
0127:
0128: if (listener != null) {
0129: listener.onAfterRemove(scFrameworkVersion);
0130: }
0131:
0132: return scFrameworkVersion;
0133: }
0134:
0135: protected SCFrameworkVersion removeImpl(
0136: SCFrameworkVersion scFrameworkVersion)
0137: throws SystemException {
0138: try {
0139: clearSCProductVersions.clear(scFrameworkVersion
0140: .getPrimaryKey());
0141: } catch (Exception e) {
0142: throw HibernateUtil.processException(e);
0143: } finally {
0144: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
0145: }
0146:
0147: Session session = null;
0148:
0149: try {
0150: session = openSession();
0151:
0152: session.delete(scFrameworkVersion);
0153:
0154: session.flush();
0155:
0156: return scFrameworkVersion;
0157: } catch (Exception e) {
0158: throw HibernateUtil.processException(e);
0159: } finally {
0160: closeSession(session);
0161:
0162: FinderCache.clearCache(SCFrameworkVersion.class.getName());
0163: }
0164: }
0165:
0166: public SCFrameworkVersion update(
0167: SCFrameworkVersion scFrameworkVersion)
0168: throws SystemException {
0169: return update(scFrameworkVersion, false);
0170: }
0171:
0172: public SCFrameworkVersion update(
0173: SCFrameworkVersion scFrameworkVersion, boolean merge)
0174: throws SystemException {
0175: ModelListener listener = _getListener();
0176:
0177: boolean isNew = scFrameworkVersion.isNew();
0178:
0179: if (listener != null) {
0180: if (isNew) {
0181: listener.onBeforeCreate(scFrameworkVersion);
0182: } else {
0183: listener.onBeforeUpdate(scFrameworkVersion);
0184: }
0185: }
0186:
0187: scFrameworkVersion = updateImpl(scFrameworkVersion, merge);
0188:
0189: if (listener != null) {
0190: if (isNew) {
0191: listener.onAfterCreate(scFrameworkVersion);
0192: } else {
0193: listener.onAfterUpdate(scFrameworkVersion);
0194: }
0195: }
0196:
0197: return scFrameworkVersion;
0198: }
0199:
0200: public SCFrameworkVersion updateImpl(
0201: com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion,
0202: boolean merge) throws SystemException {
0203: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
0204:
0205: Session session = null;
0206:
0207: try {
0208: session = openSession();
0209:
0210: if (merge) {
0211: session.merge(scFrameworkVersion);
0212: } else {
0213: if (scFrameworkVersion.isNew()) {
0214: session.save(scFrameworkVersion);
0215: }
0216: }
0217:
0218: session.flush();
0219:
0220: scFrameworkVersion.setNew(false);
0221:
0222: return scFrameworkVersion;
0223: } catch (Exception e) {
0224: throw HibernateUtil.processException(e);
0225: } finally {
0226: closeSession(session);
0227:
0228: FinderCache.clearCache(SCFrameworkVersion.class.getName());
0229: }
0230: }
0231:
0232: public SCFrameworkVersion findByPrimaryKey(long frameworkVersionId)
0233: throws NoSuchFrameworkVersionException, SystemException {
0234: SCFrameworkVersion scFrameworkVersion = fetchByPrimaryKey(frameworkVersionId);
0235:
0236: if (scFrameworkVersion == null) {
0237: if (_log.isWarnEnabled()) {
0238: _log
0239: .warn("No SCFrameworkVersion exists with the primary key "
0240: + frameworkVersionId);
0241: }
0242:
0243: throw new NoSuchFrameworkVersionException(
0244: "No SCFrameworkVersion exists with the primary key "
0245: + frameworkVersionId);
0246: }
0247:
0248: return scFrameworkVersion;
0249: }
0250:
0251: public SCFrameworkVersion fetchByPrimaryKey(long frameworkVersionId)
0252: throws SystemException {
0253: Session session = null;
0254:
0255: try {
0256: session = openSession();
0257:
0258: return (SCFrameworkVersion) session.get(
0259: SCFrameworkVersionImpl.class, new Long(
0260: frameworkVersionId));
0261: } catch (Exception e) {
0262: throw HibernateUtil.processException(e);
0263: } finally {
0264: closeSession(session);
0265: }
0266: }
0267:
0268: public List findByGroupId(long groupId) throws SystemException {
0269: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
0270: String finderClassName = SCFrameworkVersion.class.getName();
0271: String finderMethodName = "findByGroupId";
0272: String[] finderParams = new String[] { Long.class.getName() };
0273: Object[] finderArgs = new Object[] { new Long(groupId) };
0274:
0275: Object result = null;
0276:
0277: if (finderClassNameCacheEnabled) {
0278: result = FinderCache.getResult(finderClassName,
0279: finderMethodName, finderParams, finderArgs,
0280: getSessionFactory());
0281: }
0282:
0283: if (result == null) {
0284: Session session = null;
0285:
0286: try {
0287: session = openSession();
0288:
0289: StringMaker query = new StringMaker();
0290:
0291: query
0292: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0293:
0294: query.append("groupId = ?");
0295:
0296: query.append(" ");
0297:
0298: query.append("ORDER BY ");
0299:
0300: query.append("priority ASC, ");
0301: query.append("name ASC");
0302:
0303: Query q = session.createQuery(query.toString());
0304:
0305: int queryPos = 0;
0306:
0307: q.setLong(queryPos++, groupId);
0308:
0309: List list = q.list();
0310:
0311: FinderCache.putResult(finderClassNameCacheEnabled,
0312: finderClassName, finderMethodName,
0313: finderParams, finderArgs, list);
0314:
0315: return list;
0316: } catch (Exception e) {
0317: throw HibernateUtil.processException(e);
0318: } finally {
0319: closeSession(session);
0320: }
0321: } else {
0322: return (List) result;
0323: }
0324: }
0325:
0326: public List findByGroupId(long groupId, int begin, int end)
0327: throws SystemException {
0328: return findByGroupId(groupId, begin, end, null);
0329: }
0330:
0331: public List findByGroupId(long groupId, int begin, int end,
0332: OrderByComparator obc) throws SystemException {
0333: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
0334: String finderClassName = SCFrameworkVersion.class.getName();
0335: String finderMethodName = "findByGroupId";
0336: String[] finderParams = new String[] { Long.class.getName(),
0337:
0338: "java.lang.Integer", "java.lang.Integer",
0339: "com.liferay.portal.kernel.util.OrderByComparator" };
0340: Object[] finderArgs = new Object[] { new Long(groupId),
0341:
0342: String.valueOf(begin), String.valueOf(end), String.valueOf(obc) };
0343:
0344: Object result = null;
0345:
0346: if (finderClassNameCacheEnabled) {
0347: result = FinderCache.getResult(finderClassName,
0348: finderMethodName, finderParams, finderArgs,
0349: getSessionFactory());
0350: }
0351:
0352: if (result == null) {
0353: Session session = null;
0354:
0355: try {
0356: session = openSession();
0357:
0358: StringMaker query = new StringMaker();
0359:
0360: query
0361: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0362:
0363: query.append("groupId = ?");
0364:
0365: query.append(" ");
0366:
0367: if (obc != null) {
0368: query.append("ORDER BY ");
0369: query.append(obc.getOrderBy());
0370: }
0371:
0372: else {
0373: query.append("ORDER BY ");
0374:
0375: query.append("priority ASC, ");
0376: query.append("name ASC");
0377: }
0378:
0379: Query q = session.createQuery(query.toString());
0380:
0381: int queryPos = 0;
0382:
0383: q.setLong(queryPos++, groupId);
0384:
0385: List list = QueryUtil.list(q, getDialect(), begin, end);
0386:
0387: FinderCache.putResult(finderClassNameCacheEnabled,
0388: finderClassName, finderMethodName,
0389: finderParams, finderArgs, list);
0390:
0391: return list;
0392: } catch (Exception e) {
0393: throw HibernateUtil.processException(e);
0394: } finally {
0395: closeSession(session);
0396: }
0397: } else {
0398: return (List) result;
0399: }
0400: }
0401:
0402: public SCFrameworkVersion findByGroupId_First(long groupId,
0403: OrderByComparator obc)
0404: throws NoSuchFrameworkVersionException, SystemException {
0405: List list = findByGroupId(groupId, 0, 1, obc);
0406:
0407: if (list.size() == 0) {
0408: StringMaker msg = new StringMaker();
0409:
0410: msg.append("No SCFrameworkVersion exists with the key {");
0411:
0412: msg.append("groupId=" + groupId);
0413:
0414: msg.append(StringPool.CLOSE_CURLY_BRACE);
0415:
0416: throw new NoSuchFrameworkVersionException(msg.toString());
0417: } else {
0418: return (SCFrameworkVersion) list.get(0);
0419: }
0420: }
0421:
0422: public SCFrameworkVersion findByGroupId_Last(long groupId,
0423: OrderByComparator obc)
0424: throws NoSuchFrameworkVersionException, SystemException {
0425: int count = countByGroupId(groupId);
0426:
0427: List list = findByGroupId(groupId, count - 1, count, obc);
0428:
0429: if (list.size() == 0) {
0430: StringMaker msg = new StringMaker();
0431:
0432: msg.append("No SCFrameworkVersion exists with the key {");
0433:
0434: msg.append("groupId=" + groupId);
0435:
0436: msg.append(StringPool.CLOSE_CURLY_BRACE);
0437:
0438: throw new NoSuchFrameworkVersionException(msg.toString());
0439: } else {
0440: return (SCFrameworkVersion) list.get(0);
0441: }
0442: }
0443:
0444: public SCFrameworkVersion[] findByGroupId_PrevAndNext(
0445: long frameworkVersionId, long groupId, OrderByComparator obc)
0446: throws NoSuchFrameworkVersionException, SystemException {
0447: SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
0448:
0449: int count = countByGroupId(groupId);
0450:
0451: Session session = null;
0452:
0453: try {
0454: session = openSession();
0455:
0456: StringMaker query = new StringMaker();
0457:
0458: query
0459: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0460:
0461: query.append("groupId = ?");
0462:
0463: query.append(" ");
0464:
0465: if (obc != null) {
0466: query.append("ORDER BY ");
0467: query.append(obc.getOrderBy());
0468: }
0469:
0470: else {
0471: query.append("ORDER BY ");
0472:
0473: query.append("priority ASC, ");
0474: query.append("name ASC");
0475: }
0476:
0477: Query q = session.createQuery(query.toString());
0478:
0479: int queryPos = 0;
0480:
0481: q.setLong(queryPos++, groupId);
0482:
0483: Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
0484: scFrameworkVersion);
0485:
0486: SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
0487:
0488: array[0] = (SCFrameworkVersion) objArray[0];
0489: array[1] = (SCFrameworkVersion) objArray[1];
0490: array[2] = (SCFrameworkVersion) objArray[2];
0491:
0492: return array;
0493: } catch (Exception e) {
0494: throw HibernateUtil.processException(e);
0495: } finally {
0496: closeSession(session);
0497: }
0498: }
0499:
0500: public List findByCompanyId(long companyId) throws SystemException {
0501: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
0502: String finderClassName = SCFrameworkVersion.class.getName();
0503: String finderMethodName = "findByCompanyId";
0504: String[] finderParams = new String[] { Long.class.getName() };
0505: Object[] finderArgs = new Object[] { new Long(companyId) };
0506:
0507: Object result = null;
0508:
0509: if (finderClassNameCacheEnabled) {
0510: result = FinderCache.getResult(finderClassName,
0511: finderMethodName, finderParams, finderArgs,
0512: getSessionFactory());
0513: }
0514:
0515: if (result == null) {
0516: Session session = null;
0517:
0518: try {
0519: session = openSession();
0520:
0521: StringMaker query = new StringMaker();
0522:
0523: query
0524: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0525:
0526: query.append("companyId = ?");
0527:
0528: query.append(" ");
0529:
0530: query.append("ORDER BY ");
0531:
0532: query.append("priority ASC, ");
0533: query.append("name ASC");
0534:
0535: Query q = session.createQuery(query.toString());
0536:
0537: int queryPos = 0;
0538:
0539: q.setLong(queryPos++, companyId);
0540:
0541: List list = q.list();
0542:
0543: FinderCache.putResult(finderClassNameCacheEnabled,
0544: finderClassName, finderMethodName,
0545: finderParams, finderArgs, list);
0546:
0547: return list;
0548: } catch (Exception e) {
0549: throw HibernateUtil.processException(e);
0550: } finally {
0551: closeSession(session);
0552: }
0553: } else {
0554: return (List) result;
0555: }
0556: }
0557:
0558: public List findByCompanyId(long companyId, int begin, int end)
0559: throws SystemException {
0560: return findByCompanyId(companyId, begin, end, null);
0561: }
0562:
0563: public List findByCompanyId(long companyId, int begin, int end,
0564: OrderByComparator obc) throws SystemException {
0565: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
0566: String finderClassName = SCFrameworkVersion.class.getName();
0567: String finderMethodName = "findByCompanyId";
0568: String[] finderParams = new String[] { Long.class.getName(),
0569:
0570: "java.lang.Integer", "java.lang.Integer",
0571: "com.liferay.portal.kernel.util.OrderByComparator" };
0572: Object[] finderArgs = new Object[] { new Long(companyId),
0573:
0574: String.valueOf(begin), String.valueOf(end), String.valueOf(obc) };
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.softwarecatalog.model.SCFrameworkVersion WHERE ");
0594:
0595: query.append("companyId = ?");
0596:
0597: query.append(" ");
0598:
0599: if (obc != null) {
0600: query.append("ORDER BY ");
0601: query.append(obc.getOrderBy());
0602: }
0603:
0604: else {
0605: query.append("ORDER BY ");
0606:
0607: query.append("priority ASC, ");
0608: query.append("name ASC");
0609: }
0610:
0611: Query q = session.createQuery(query.toString());
0612:
0613: int queryPos = 0;
0614:
0615: q.setLong(queryPos++, companyId);
0616:
0617: List list = QueryUtil.list(q, getDialect(), begin, end);
0618:
0619: FinderCache.putResult(finderClassNameCacheEnabled,
0620: finderClassName, finderMethodName,
0621: finderParams, finderArgs, list);
0622:
0623: return list;
0624: } catch (Exception e) {
0625: throw HibernateUtil.processException(e);
0626: } finally {
0627: closeSession(session);
0628: }
0629: } else {
0630: return (List) result;
0631: }
0632: }
0633:
0634: public SCFrameworkVersion findByCompanyId_First(long companyId,
0635: OrderByComparator obc)
0636: throws NoSuchFrameworkVersionException, SystemException {
0637: List list = findByCompanyId(companyId, 0, 1, obc);
0638:
0639: if (list.size() == 0) {
0640: StringMaker msg = new StringMaker();
0641:
0642: msg.append("No SCFrameworkVersion exists with the key {");
0643:
0644: msg.append("companyId=" + companyId);
0645:
0646: msg.append(StringPool.CLOSE_CURLY_BRACE);
0647:
0648: throw new NoSuchFrameworkVersionException(msg.toString());
0649: } else {
0650: return (SCFrameworkVersion) list.get(0);
0651: }
0652: }
0653:
0654: public SCFrameworkVersion findByCompanyId_Last(long companyId,
0655: OrderByComparator obc)
0656: throws NoSuchFrameworkVersionException, SystemException {
0657: int count = countByCompanyId(companyId);
0658:
0659: List list = findByCompanyId(companyId, count - 1, count, obc);
0660:
0661: if (list.size() == 0) {
0662: StringMaker msg = new StringMaker();
0663:
0664: msg.append("No SCFrameworkVersion exists with the key {");
0665:
0666: msg.append("companyId=" + companyId);
0667:
0668: msg.append(StringPool.CLOSE_CURLY_BRACE);
0669:
0670: throw new NoSuchFrameworkVersionException(msg.toString());
0671: } else {
0672: return (SCFrameworkVersion) list.get(0);
0673: }
0674: }
0675:
0676: public SCFrameworkVersion[] findByCompanyId_PrevAndNext(
0677: long frameworkVersionId, long companyId,
0678: OrderByComparator obc)
0679: throws NoSuchFrameworkVersionException, SystemException {
0680: SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
0681:
0682: int count = countByCompanyId(companyId);
0683:
0684: Session session = null;
0685:
0686: try {
0687: session = openSession();
0688:
0689: StringMaker query = new StringMaker();
0690:
0691: query
0692: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0693:
0694: query.append("companyId = ?");
0695:
0696: query.append(" ");
0697:
0698: if (obc != null) {
0699: query.append("ORDER BY ");
0700: query.append(obc.getOrderBy());
0701: }
0702:
0703: else {
0704: query.append("ORDER BY ");
0705:
0706: query.append("priority ASC, ");
0707: query.append("name ASC");
0708: }
0709:
0710: Query q = session.createQuery(query.toString());
0711:
0712: int queryPos = 0;
0713:
0714: q.setLong(queryPos++, companyId);
0715:
0716: Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
0717: scFrameworkVersion);
0718:
0719: SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
0720:
0721: array[0] = (SCFrameworkVersion) objArray[0];
0722: array[1] = (SCFrameworkVersion) objArray[1];
0723: array[2] = (SCFrameworkVersion) objArray[2];
0724:
0725: return array;
0726: } catch (Exception e) {
0727: throw HibernateUtil.processException(e);
0728: } finally {
0729: closeSession(session);
0730: }
0731: }
0732:
0733: public List findByG_A(long groupId, boolean active)
0734: throws SystemException {
0735: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
0736: String finderClassName = SCFrameworkVersion.class.getName();
0737: String finderMethodName = "findByG_A";
0738: String[] finderParams = new String[] { Long.class.getName(),
0739: Boolean.class.getName() };
0740: Object[] finderArgs = new Object[] { new Long(groupId),
0741: Boolean.valueOf(active) };
0742:
0743: Object result = null;
0744:
0745: if (finderClassNameCacheEnabled) {
0746: result = FinderCache.getResult(finderClassName,
0747: finderMethodName, finderParams, finderArgs,
0748: getSessionFactory());
0749: }
0750:
0751: if (result == null) {
0752: Session session = null;
0753:
0754: try {
0755: session = openSession();
0756:
0757: StringMaker query = new StringMaker();
0758:
0759: query
0760: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0761:
0762: query.append("groupId = ?");
0763:
0764: query.append(" AND ");
0765:
0766: query.append("active_ = ?");
0767:
0768: query.append(" ");
0769:
0770: query.append("ORDER BY ");
0771:
0772: query.append("priority ASC, ");
0773: query.append("name ASC");
0774:
0775: Query q = session.createQuery(query.toString());
0776:
0777: int queryPos = 0;
0778:
0779: q.setLong(queryPos++, groupId);
0780:
0781: q.setBoolean(queryPos++, active);
0782:
0783: List list = q.list();
0784:
0785: FinderCache.putResult(finderClassNameCacheEnabled,
0786: finderClassName, finderMethodName,
0787: finderParams, finderArgs, list);
0788:
0789: return list;
0790: } catch (Exception e) {
0791: throw HibernateUtil.processException(e);
0792: } finally {
0793: closeSession(session);
0794: }
0795: } else {
0796: return (List) result;
0797: }
0798: }
0799:
0800: public List findByG_A(long groupId, boolean active, int begin,
0801: int end) throws SystemException {
0802: return findByG_A(groupId, active, begin, end, null);
0803: }
0804:
0805: public List findByG_A(long groupId, boolean active, int begin,
0806: int end, OrderByComparator obc) throws SystemException {
0807: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
0808: String finderClassName = SCFrameworkVersion.class.getName();
0809: String finderMethodName = "findByG_A";
0810: String[] finderParams = new String[] { Long.class.getName(),
0811: Boolean.class.getName(),
0812:
0813: "java.lang.Integer", "java.lang.Integer",
0814: "com.liferay.portal.kernel.util.OrderByComparator" };
0815: Object[] finderArgs = new Object[] { new Long(groupId),
0816: Boolean.valueOf(active),
0817:
0818: String.valueOf(begin), String.valueOf(end),
0819: String.valueOf(obc) };
0820:
0821: Object result = null;
0822:
0823: if (finderClassNameCacheEnabled) {
0824: result = FinderCache.getResult(finderClassName,
0825: finderMethodName, finderParams, finderArgs,
0826: getSessionFactory());
0827: }
0828:
0829: if (result == null) {
0830: Session session = null;
0831:
0832: try {
0833: session = openSession();
0834:
0835: StringMaker query = new StringMaker();
0836:
0837: query
0838: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
0839:
0840: query.append("groupId = ?");
0841:
0842: query.append(" AND ");
0843:
0844: query.append("active_ = ?");
0845:
0846: query.append(" ");
0847:
0848: if (obc != null) {
0849: query.append("ORDER BY ");
0850: query.append(obc.getOrderBy());
0851: }
0852:
0853: else {
0854: query.append("ORDER BY ");
0855:
0856: query.append("priority ASC, ");
0857: query.append("name ASC");
0858: }
0859:
0860: Query q = session.createQuery(query.toString());
0861:
0862: int queryPos = 0;
0863:
0864: q.setLong(queryPos++, groupId);
0865:
0866: q.setBoolean(queryPos++, active);
0867:
0868: List list = QueryUtil.list(q, getDialect(), begin, end);
0869:
0870: FinderCache.putResult(finderClassNameCacheEnabled,
0871: finderClassName, finderMethodName,
0872: finderParams, finderArgs, list);
0873:
0874: return list;
0875: } catch (Exception e) {
0876: throw HibernateUtil.processException(e);
0877: } finally {
0878: closeSession(session);
0879: }
0880: } else {
0881: return (List) result;
0882: }
0883: }
0884:
0885: public SCFrameworkVersion findByG_A_First(long groupId,
0886: boolean active, OrderByComparator obc)
0887: throws NoSuchFrameworkVersionException, SystemException {
0888: List list = findByG_A(groupId, active, 0, 1, obc);
0889:
0890: if (list.size() == 0) {
0891: StringMaker msg = new StringMaker();
0892:
0893: msg.append("No SCFrameworkVersion exists with the key {");
0894:
0895: msg.append("groupId=" + groupId);
0896:
0897: msg.append(", ");
0898: msg.append("active=" + active);
0899:
0900: msg.append(StringPool.CLOSE_CURLY_BRACE);
0901:
0902: throw new NoSuchFrameworkVersionException(msg.toString());
0903: } else {
0904: return (SCFrameworkVersion) list.get(0);
0905: }
0906: }
0907:
0908: public SCFrameworkVersion findByG_A_Last(long groupId,
0909: boolean active, OrderByComparator obc)
0910: throws NoSuchFrameworkVersionException, SystemException {
0911: int count = countByG_A(groupId, active);
0912:
0913: List list = findByG_A(groupId, active, count - 1, count, obc);
0914:
0915: if (list.size() == 0) {
0916: StringMaker msg = new StringMaker();
0917:
0918: msg.append("No SCFrameworkVersion exists with the key {");
0919:
0920: msg.append("groupId=" + groupId);
0921:
0922: msg.append(", ");
0923: msg.append("active=" + active);
0924:
0925: msg.append(StringPool.CLOSE_CURLY_BRACE);
0926:
0927: throw new NoSuchFrameworkVersionException(msg.toString());
0928: } else {
0929: return (SCFrameworkVersion) list.get(0);
0930: }
0931: }
0932:
0933: public SCFrameworkVersion[] findByG_A_PrevAndNext(
0934: long frameworkVersionId, long groupId, boolean active,
0935: OrderByComparator obc)
0936: throws NoSuchFrameworkVersionException, SystemException {
0937: SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
0938:
0939: int count = countByG_A(groupId, active);
0940:
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.softwarecatalog.model.SCFrameworkVersion WHERE ");
0950:
0951: query.append("groupId = ?");
0952:
0953: query.append(" AND ");
0954:
0955: query.append("active_ = ?");
0956:
0957: query.append(" ");
0958:
0959: if (obc != null) {
0960: query.append("ORDER BY ");
0961: query.append(obc.getOrderBy());
0962: }
0963:
0964: else {
0965: query.append("ORDER BY ");
0966:
0967: query.append("priority ASC, ");
0968: query.append("name ASC");
0969: }
0970:
0971: Query q = session.createQuery(query.toString());
0972:
0973: int queryPos = 0;
0974:
0975: q.setLong(queryPos++, groupId);
0976:
0977: q.setBoolean(queryPos++, active);
0978:
0979: Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
0980: scFrameworkVersion);
0981:
0982: SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
0983:
0984: array[0] = (SCFrameworkVersion) objArray[0];
0985: array[1] = (SCFrameworkVersion) objArray[1];
0986: array[2] = (SCFrameworkVersion) objArray[2];
0987:
0988: return array;
0989: } catch (Exception e) {
0990: throw HibernateUtil.processException(e);
0991: } finally {
0992: closeSession(session);
0993: }
0994: }
0995:
0996: public List findWithDynamicQuery(
0997: DynamicQueryInitializer queryInitializer)
0998: throws SystemException {
0999: Session session = null;
1000:
1001: try {
1002: session = openSession();
1003:
1004: DynamicQuery query = queryInitializer.initialize(session);
1005:
1006: return query.list();
1007: } catch (Exception e) {
1008: throw HibernateUtil.processException(e);
1009: } finally {
1010: closeSession(session);
1011: }
1012: }
1013:
1014: public List findWithDynamicQuery(
1015: DynamicQueryInitializer queryInitializer, int begin, int end)
1016: throws SystemException {
1017: Session session = null;
1018:
1019: try {
1020: session = openSession();
1021:
1022: DynamicQuery query = queryInitializer.initialize(session);
1023:
1024: query.setLimit(begin, end);
1025:
1026: return query.list();
1027: } catch (Exception e) {
1028: throw HibernateUtil.processException(e);
1029: } finally {
1030: closeSession(session);
1031: }
1032: }
1033:
1034: public List findAll() throws SystemException {
1035: return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1036: }
1037:
1038: public List findAll(int begin, int end) throws SystemException {
1039: return findAll(begin, end, null);
1040: }
1041:
1042: public List findAll(int begin, int end, OrderByComparator obc)
1043: throws SystemException {
1044: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1045: String finderClassName = SCFrameworkVersion.class.getName();
1046: String finderMethodName = "findAll";
1047: String[] finderParams = new String[] { "java.lang.Integer",
1048: "java.lang.Integer",
1049: "com.liferay.portal.kernel.util.OrderByComparator" };
1050: Object[] finderArgs = new Object[] { String.valueOf(begin),
1051: String.valueOf(end), String.valueOf(obc) };
1052:
1053: Object result = null;
1054:
1055: if (finderClassNameCacheEnabled) {
1056: result = FinderCache.getResult(finderClassName,
1057: finderMethodName, finderParams, finderArgs,
1058: getSessionFactory());
1059: }
1060:
1061: if (result == null) {
1062: Session session = null;
1063:
1064: try {
1065: session = openSession();
1066:
1067: StringMaker query = new StringMaker();
1068:
1069: query
1070: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion ");
1071:
1072: if (obc != null) {
1073: query.append("ORDER BY ");
1074: query.append(obc.getOrderBy());
1075: }
1076:
1077: else {
1078: query.append("ORDER BY ");
1079:
1080: query.append("priority ASC, ");
1081: query.append("name ASC");
1082: }
1083:
1084: Query q = session.createQuery(query.toString());
1085:
1086: List list = QueryUtil.list(q, getDialect(), begin, end);
1087:
1088: if (obc == null) {
1089: Collections.sort(list);
1090: }
1091:
1092: FinderCache.putResult(finderClassNameCacheEnabled,
1093: finderClassName, finderMethodName,
1094: finderParams, finderArgs, list);
1095:
1096: return list;
1097: } catch (Exception e) {
1098: throw HibernateUtil.processException(e);
1099: } finally {
1100: closeSession(session);
1101: }
1102: } else {
1103: return (List) result;
1104: }
1105: }
1106:
1107: public void removeByGroupId(long groupId) throws SystemException {
1108: Iterator itr = findByGroupId(groupId).iterator();
1109:
1110: while (itr.hasNext()) {
1111: SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion) itr
1112: .next();
1113:
1114: remove(scFrameworkVersion);
1115: }
1116: }
1117:
1118: public void removeByCompanyId(long companyId)
1119: throws SystemException {
1120: Iterator itr = findByCompanyId(companyId).iterator();
1121:
1122: while (itr.hasNext()) {
1123: SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion) itr
1124: .next();
1125:
1126: remove(scFrameworkVersion);
1127: }
1128: }
1129:
1130: public void removeByG_A(long groupId, boolean active)
1131: throws SystemException {
1132: Iterator itr = findByG_A(groupId, active).iterator();
1133:
1134: while (itr.hasNext()) {
1135: SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion) itr
1136: .next();
1137:
1138: remove(scFrameworkVersion);
1139: }
1140: }
1141:
1142: public void removeAll() throws SystemException {
1143: Iterator itr = findAll().iterator();
1144:
1145: while (itr.hasNext()) {
1146: remove((SCFrameworkVersion) itr.next());
1147: }
1148: }
1149:
1150: public int countByGroupId(long groupId) throws SystemException {
1151: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1152: String finderClassName = SCFrameworkVersion.class.getName();
1153: String finderMethodName = "countByGroupId";
1154: String[] finderParams = new String[] { Long.class.getName() };
1155: Object[] finderArgs = new Object[] { new Long(groupId) };
1156:
1157: Object result = null;
1158:
1159: if (finderClassNameCacheEnabled) {
1160: result = FinderCache.getResult(finderClassName,
1161: finderMethodName, finderParams, finderArgs,
1162: getSessionFactory());
1163: }
1164:
1165: if (result == null) {
1166: Session session = null;
1167:
1168: try {
1169: session = openSession();
1170:
1171: StringMaker query = new StringMaker();
1172:
1173: query.append("SELECT COUNT(*) ");
1174: query
1175: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
1176:
1177: query.append("groupId = ?");
1178:
1179: query.append(" ");
1180:
1181: Query q = session.createQuery(query.toString());
1182:
1183: int queryPos = 0;
1184:
1185: q.setLong(queryPos++, groupId);
1186:
1187: Long count = null;
1188:
1189: Iterator itr = q.list().iterator();
1190:
1191: if (itr.hasNext()) {
1192: count = (Long) itr.next();
1193: }
1194:
1195: if (count == null) {
1196: count = new Long(0);
1197: }
1198:
1199: FinderCache.putResult(finderClassNameCacheEnabled,
1200: finderClassName, finderMethodName,
1201: finderParams, finderArgs, count);
1202:
1203: return count.intValue();
1204: } catch (Exception e) {
1205: throw HibernateUtil.processException(e);
1206: } finally {
1207: closeSession(session);
1208: }
1209: } else {
1210: return ((Long) result).intValue();
1211: }
1212: }
1213:
1214: public int countByCompanyId(long companyId) throws SystemException {
1215: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1216: String finderClassName = SCFrameworkVersion.class.getName();
1217: String finderMethodName = "countByCompanyId";
1218: String[] finderParams = new String[] { Long.class.getName() };
1219: Object[] finderArgs = new Object[] { new Long(companyId) };
1220:
1221: Object result = null;
1222:
1223: if (finderClassNameCacheEnabled) {
1224: result = FinderCache.getResult(finderClassName,
1225: finderMethodName, finderParams, finderArgs,
1226: getSessionFactory());
1227: }
1228:
1229: if (result == null) {
1230: Session session = null;
1231:
1232: try {
1233: session = openSession();
1234:
1235: StringMaker query = new StringMaker();
1236:
1237: query.append("SELECT COUNT(*) ");
1238: query
1239: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
1240:
1241: query.append("companyId = ?");
1242:
1243: query.append(" ");
1244:
1245: Query q = session.createQuery(query.toString());
1246:
1247: int queryPos = 0;
1248:
1249: q.setLong(queryPos++, companyId);
1250:
1251: Long count = null;
1252:
1253: Iterator itr = q.list().iterator();
1254:
1255: if (itr.hasNext()) {
1256: count = (Long) itr.next();
1257: }
1258:
1259: if (count == null) {
1260: count = new Long(0);
1261: }
1262:
1263: FinderCache.putResult(finderClassNameCacheEnabled,
1264: finderClassName, finderMethodName,
1265: finderParams, finderArgs, count);
1266:
1267: return count.intValue();
1268: } catch (Exception e) {
1269: throw HibernateUtil.processException(e);
1270: } finally {
1271: closeSession(session);
1272: }
1273: } else {
1274: return ((Long) result).intValue();
1275: }
1276: }
1277:
1278: public int countByG_A(long groupId, boolean active)
1279: throws SystemException {
1280: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1281: String finderClassName = SCFrameworkVersion.class.getName();
1282: String finderMethodName = "countByG_A";
1283: String[] finderParams = new String[] { Long.class.getName(),
1284: Boolean.class.getName() };
1285: Object[] finderArgs = new Object[] { new Long(groupId),
1286: Boolean.valueOf(active) };
1287:
1288: Object result = null;
1289:
1290: if (finderClassNameCacheEnabled) {
1291: result = FinderCache.getResult(finderClassName,
1292: finderMethodName, finderParams, finderArgs,
1293: getSessionFactory());
1294: }
1295:
1296: if (result == null) {
1297: Session session = null;
1298:
1299: try {
1300: session = openSession();
1301:
1302: StringMaker query = new StringMaker();
1303:
1304: query.append("SELECT COUNT(*) ");
1305: query
1306: .append("FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion WHERE ");
1307:
1308: query.append("groupId = ?");
1309:
1310: query.append(" AND ");
1311:
1312: query.append("active_ = ?");
1313:
1314: query.append(" ");
1315:
1316: Query q = session.createQuery(query.toString());
1317:
1318: int queryPos = 0;
1319:
1320: q.setLong(queryPos++, groupId);
1321:
1322: q.setBoolean(queryPos++, active);
1323:
1324: Long count = null;
1325:
1326: Iterator itr = q.list().iterator();
1327:
1328: if (itr.hasNext()) {
1329: count = (Long) itr.next();
1330: }
1331:
1332: if (count == null) {
1333: count = new Long(0);
1334: }
1335:
1336: FinderCache.putResult(finderClassNameCacheEnabled,
1337: finderClassName, finderMethodName,
1338: finderParams, finderArgs, count);
1339:
1340: return count.intValue();
1341: } catch (Exception e) {
1342: throw HibernateUtil.processException(e);
1343: } finally {
1344: closeSession(session);
1345: }
1346: } else {
1347: return ((Long) result).intValue();
1348: }
1349: }
1350:
1351: public int countAll() throws SystemException {
1352: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED;
1353: String finderClassName = SCFrameworkVersion.class.getName();
1354: String finderMethodName = "countAll";
1355: String[] finderParams = new String[] {};
1356: Object[] finderArgs = new Object[] {};
1357:
1358: Object result = null;
1359:
1360: if (finderClassNameCacheEnabled) {
1361: result = FinderCache.getResult(finderClassName,
1362: finderMethodName, finderParams, finderArgs,
1363: getSessionFactory());
1364: }
1365:
1366: if (result == null) {
1367: Session session = null;
1368:
1369: try {
1370: session = openSession();
1371:
1372: Query q = session
1373: .createQuery("SELECT COUNT(*) FROM com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion");
1374:
1375: Long count = null;
1376:
1377: Iterator itr = q.list().iterator();
1378:
1379: if (itr.hasNext()) {
1380: count = (Long) itr.next();
1381: }
1382:
1383: if (count == null) {
1384: count = new Long(0);
1385: }
1386:
1387: FinderCache.putResult(finderClassNameCacheEnabled,
1388: finderClassName, finderMethodName,
1389: finderParams, finderArgs, count);
1390:
1391: return count.intValue();
1392: } catch (Exception e) {
1393: throw HibernateUtil.processException(e);
1394: } finally {
1395: closeSession(session);
1396: }
1397: } else {
1398: return ((Long) result).intValue();
1399: }
1400: }
1401:
1402: public List getSCProductVersions(long pk)
1403: throws NoSuchFrameworkVersionException, SystemException {
1404: return getSCProductVersions(pk, QueryUtil.ALL_POS,
1405: QueryUtil.ALL_POS);
1406: }
1407:
1408: public List getSCProductVersions(long pk, int begin, int end)
1409: throws NoSuchFrameworkVersionException, SystemException {
1410: return getSCProductVersions(pk, begin, end, null);
1411: }
1412:
1413: public List getSCProductVersions(long pk, int begin, int end,
1414: OrderByComparator obc)
1415: throws NoSuchFrameworkVersionException, SystemException {
1416: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
1417: String finderClassName = "SCFrameworkVersi_SCProductVers";
1418: String finderMethodName = "getSCProductVersions";
1419: String[] finderParams = new String[] { Long.class.getName(),
1420: "java.lang.Integer", "java.lang.Integer",
1421: "com.liferay.portal.kernel.util.OrderByComparator" };
1422: Object[] finderArgs = new Object[] { new Long(pk),
1423: String.valueOf(begin), String.valueOf(end),
1424: String.valueOf(obc) };
1425:
1426: Object result = null;
1427:
1428: if (finderClassNameCacheEnabled) {
1429: result = FinderCache.getResult(finderClassName,
1430: finderMethodName, finderParams, finderArgs,
1431: getSessionFactory());
1432: }
1433:
1434: if (result == null) {
1435: Session session = null;
1436:
1437: try {
1438: session = HibernateUtil.openSession();
1439:
1440: StringMaker sm = new StringMaker();
1441:
1442: sm.append(_SQL_GETSCPRODUCTVERSIONS);
1443:
1444: if (obc != null) {
1445: sm.append("ORDER BY ");
1446: sm.append(obc.getOrderBy());
1447: }
1448:
1449: else {
1450: sm.append("ORDER BY ");
1451:
1452: sm.append("SCProductVersion.createDate DESC");
1453: }
1454:
1455: String sql = sm.toString();
1456:
1457: SQLQuery q = session.createSQLQuery(sql);
1458:
1459: q
1460: .addEntity(
1461: "SCProductVersion",
1462: com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionImpl.class);
1463:
1464: QueryPos qPos = QueryPos.getInstance(q);
1465:
1466: qPos.add(pk);
1467:
1468: List list = QueryUtil.list(q, getDialect(), begin, end);
1469:
1470: FinderCache.putResult(finderClassNameCacheEnabled,
1471: finderClassName, finderMethodName,
1472: finderParams, finderArgs, list);
1473:
1474: return list;
1475: } catch (Exception e) {
1476: throw new SystemException(e);
1477: } finally {
1478: closeSession(session);
1479: }
1480: } else {
1481: return (List) result;
1482: }
1483: }
1484:
1485: public int getSCProductVersionsSize(long pk) throws SystemException {
1486: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
1487: String finderClassName = "SCFrameworkVersi_SCProductVers";
1488: String finderMethodName = "getSCProductVersionsSize";
1489: String[] finderParams = new String[] { Long.class.getName() };
1490: Object[] finderArgs = new Object[] { new Long(pk) };
1491:
1492: Object result = null;
1493:
1494: if (finderClassNameCacheEnabled) {
1495: result = FinderCache.getResult(finderClassName,
1496: finderMethodName, finderParams, finderArgs,
1497: getSessionFactory());
1498: }
1499:
1500: if (result == null) {
1501: Session session = null;
1502:
1503: try {
1504: session = openSession();
1505:
1506: SQLQuery q = session
1507: .createSQLQuery(_SQL_GETSCPRODUCTVERSIONSSIZE);
1508:
1509: q.addScalar(HibernateUtil.getCountColumnName(),
1510: Hibernate.LONG);
1511:
1512: QueryPos qPos = QueryPos.getInstance(q);
1513:
1514: qPos.add(pk);
1515:
1516: Long count = null;
1517:
1518: Iterator itr = q.list().iterator();
1519:
1520: if (itr.hasNext()) {
1521: count = (Long) itr.next();
1522: }
1523:
1524: if (count == null) {
1525: count = new Long(0);
1526: }
1527:
1528: FinderCache.putResult(finderClassNameCacheEnabled,
1529: finderClassName, finderMethodName,
1530: finderParams, finderArgs, count);
1531:
1532: return count.intValue();
1533: } catch (Exception e) {
1534: throw HibernateUtil.processException(e);
1535: } finally {
1536: closeSession(session);
1537: }
1538: } else {
1539: return ((Long) result).intValue();
1540: }
1541: }
1542:
1543: public boolean containsSCProductVersion(long pk,
1544: long scProductVersionPK) throws SystemException {
1545: boolean finderClassNameCacheEnabled = SCFrameworkVersionModelImpl.CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS;
1546: String finderClassName = "SCFrameworkVersi_SCProductVers";
1547: String finderMethodName = "containsSCProductVersions";
1548: String[] finderParams = new String[] { Long.class.getName(),
1549:
1550: Long.class.getName() };
1551: Object[] finderArgs = new Object[] { new Long(pk),
1552:
1553: new Long(scProductVersionPK) };
1554:
1555: Object result = null;
1556:
1557: if (finderClassNameCacheEnabled) {
1558: result = FinderCache.getResult(finderClassName,
1559: finderMethodName, finderParams, finderArgs,
1560: getSessionFactory());
1561: }
1562:
1563: if (result == null) {
1564: try {
1565: Boolean value = Boolean
1566: .valueOf(containsSCProductVersion.contains(pk,
1567: scProductVersionPK));
1568:
1569: FinderCache.putResult(finderClassNameCacheEnabled,
1570: finderClassName, finderMethodName,
1571: finderParams, finderArgs, value);
1572:
1573: return value.booleanValue();
1574: } catch (DataAccessException dae) {
1575: throw new SystemException(dae);
1576: }
1577: } else {
1578: return ((Boolean) result).booleanValue();
1579: }
1580: }
1581:
1582: public boolean containsSCProductVersions(long pk)
1583: throws SystemException {
1584: if (getSCProductVersionsSize(pk) > 0) {
1585: return true;
1586: } else {
1587: return false;
1588: }
1589: }
1590:
1591: public void addSCProductVersion(long pk, long scProductVersionPK)
1592: throws NoSuchFrameworkVersionException,
1593: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1594: SystemException {
1595: try {
1596: addSCProductVersion.add(pk, scProductVersionPK);
1597: } catch (DataAccessException dae) {
1598: throw new SystemException(dae);
1599: } finally {
1600: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1601: }
1602: }
1603:
1604: public void addSCProductVersion(
1605: long pk,
1606: com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1607: throws NoSuchFrameworkVersionException,
1608: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1609: SystemException {
1610: try {
1611: addSCProductVersion.add(pk, scProductVersion
1612: .getPrimaryKey());
1613: } catch (DataAccessException dae) {
1614: throw new SystemException(dae);
1615: } finally {
1616: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1617: }
1618: }
1619:
1620: public void addSCProductVersions(long pk, long[] scProductVersionPKs)
1621: throws NoSuchFrameworkVersionException,
1622: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1623: SystemException {
1624: try {
1625: for (int i = 0; i < scProductVersionPKs.length; i++) {
1626: addSCProductVersion.add(pk, scProductVersionPKs[i]);
1627: }
1628: } catch (DataAccessException dae) {
1629: throw new SystemException(dae);
1630: } finally {
1631: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1632: }
1633: }
1634:
1635: public void addSCProductVersions(long pk, List scProductVersions)
1636: throws NoSuchFrameworkVersionException,
1637: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1638: SystemException {
1639: try {
1640: for (int i = 0; i < scProductVersions.size(); i++) {
1641: com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion = (com.liferay.portlet.softwarecatalog.model.SCProductVersion) scProductVersions
1642: .get(i);
1643:
1644: addSCProductVersion.add(pk, scProductVersion
1645: .getPrimaryKey());
1646: }
1647: } catch (DataAccessException dae) {
1648: throw new SystemException(dae);
1649: } finally {
1650: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1651: }
1652: }
1653:
1654: public void clearSCProductVersions(long pk)
1655: throws NoSuchFrameworkVersionException, SystemException {
1656: try {
1657: clearSCProductVersions.clear(pk);
1658: } catch (DataAccessException dae) {
1659: throw new SystemException(dae);
1660: } finally {
1661: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1662: }
1663: }
1664:
1665: public void removeSCProductVersion(long pk, long scProductVersionPK)
1666: throws NoSuchFrameworkVersionException,
1667: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1668: SystemException {
1669: try {
1670: removeSCProductVersion.remove(pk, scProductVersionPK);
1671: } catch (DataAccessException dae) {
1672: throw new SystemException(dae);
1673: } finally {
1674: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1675: }
1676: }
1677:
1678: public void removeSCProductVersion(
1679: long pk,
1680: com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1681: throws NoSuchFrameworkVersionException,
1682: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1683: SystemException {
1684: try {
1685: removeSCProductVersion.remove(pk, scProductVersion
1686: .getPrimaryKey());
1687: } catch (DataAccessException dae) {
1688: throw new SystemException(dae);
1689: } finally {
1690: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1691: }
1692: }
1693:
1694: public void removeSCProductVersions(long pk,
1695: long[] scProductVersionPKs)
1696: throws NoSuchFrameworkVersionException,
1697: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1698: SystemException {
1699: try {
1700: for (int i = 0; i < scProductVersionPKs.length; i++) {
1701: removeSCProductVersion.remove(pk,
1702: scProductVersionPKs[i]);
1703: }
1704: } catch (DataAccessException dae) {
1705: throw new SystemException(dae);
1706: } finally {
1707: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1708: }
1709: }
1710:
1711: public void removeSCProductVersions(long pk, List scProductVersions)
1712: throws NoSuchFrameworkVersionException,
1713: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1714: SystemException {
1715: try {
1716: for (int i = 0; i < scProductVersions.size(); i++) {
1717: com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion = (com.liferay.portlet.softwarecatalog.model.SCProductVersion) scProductVersions
1718: .get(i);
1719:
1720: removeSCProductVersion.remove(pk, scProductVersion
1721: .getPrimaryKey());
1722: }
1723: } catch (DataAccessException dae) {
1724: throw new SystemException(dae);
1725: } finally {
1726: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1727: }
1728: }
1729:
1730: public void setSCProductVersions(long pk, long[] scProductVersionPKs)
1731: throws NoSuchFrameworkVersionException,
1732: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1733: SystemException {
1734: try {
1735: clearSCProductVersions.clear(pk);
1736:
1737: for (int i = 0; i < scProductVersionPKs.length; i++) {
1738: addSCProductVersion.add(pk, scProductVersionPKs[i]);
1739: }
1740: } catch (DataAccessException dae) {
1741: throw new SystemException(dae);
1742: } finally {
1743: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1744: }
1745: }
1746:
1747: public void setSCProductVersions(long pk, List scProductVersions)
1748: throws NoSuchFrameworkVersionException,
1749: com.liferay.portlet.softwarecatalog.NoSuchProductVersionException,
1750: SystemException {
1751: try {
1752: clearSCProductVersions.clear(pk);
1753:
1754: for (int i = 0; i < scProductVersions.size(); i++) {
1755: com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion = (com.liferay.portlet.softwarecatalog.model.SCProductVersion) scProductVersions
1756: .get(i);
1757:
1758: addSCProductVersion.add(pk, scProductVersion
1759: .getPrimaryKey());
1760: }
1761: } catch (DataAccessException dae) {
1762: throw new SystemException(dae);
1763: } finally {
1764: FinderCache.clearCache("SCFrameworkVersi_SCProductVers");
1765: }
1766: }
1767:
1768: protected void initDao() {
1769: containsSCProductVersion = new ContainsSCProductVersion(this );
1770:
1771: addSCProductVersion = new AddSCProductVersion(this );
1772: clearSCProductVersions = new ClearSCProductVersions(this );
1773: removeSCProductVersion = new RemoveSCProductVersion(this );
1774: }
1775:
1776: protected ContainsSCProductVersion containsSCProductVersion;
1777: protected AddSCProductVersion addSCProductVersion;
1778: protected ClearSCProductVersions clearSCProductVersions;
1779: protected RemoveSCProductVersion removeSCProductVersion;
1780:
1781: protected class ContainsSCProductVersion extends MappingSqlQuery {
1782: protected ContainsSCProductVersion(
1783: SCFrameworkVersionPersistenceImpl persistenceImpl) {
1784: super (persistenceImpl.getDataSource(),
1785: _SQL_CONTAINSSCPRODUCTVERSION);
1786:
1787: declareParameter(new SqlParameter(Types.BIGINT));
1788: declareParameter(new SqlParameter(Types.BIGINT));
1789:
1790: compile();
1791: }
1792:
1793: protected Object mapRow(ResultSet rs, int rowNumber)
1794: throws SQLException {
1795: return new Integer(rs.getInt("COUNT_VALUE"));
1796: }
1797:
1798: protected boolean contains(long frameworkVersionId,
1799: long productVersionId) {
1800: List results = execute(new Object[] {
1801: new Long(frameworkVersionId),
1802: new Long(productVersionId) });
1803:
1804: if (results.size() > 0) {
1805: Integer count = (Integer) results.get(0);
1806:
1807: if (count.intValue() > 0) {
1808: return true;
1809: }
1810: }
1811:
1812: return false;
1813: }
1814: }
1815:
1816: protected class AddSCProductVersion extends SqlUpdate {
1817: protected AddSCProductVersion(
1818: SCFrameworkVersionPersistenceImpl persistenceImpl) {
1819: super (
1820: persistenceImpl.getDataSource(),
1821: "INSERT INTO SCFrameworkVersi_SCProductVers (frameworkVersionId, productVersionId) VALUES (?, ?)");
1822:
1823: _persistenceImpl = persistenceImpl;
1824:
1825: declareParameter(new SqlParameter(Types.BIGINT));
1826: declareParameter(new SqlParameter(Types.BIGINT));
1827:
1828: compile();
1829: }
1830:
1831: protected void add(long frameworkVersionId,
1832: long productVersionId) {
1833: if (!_persistenceImpl.containsSCProductVersion.contains(
1834: frameworkVersionId, productVersionId)) {
1835: update(new Object[] { new Long(frameworkVersionId),
1836: new Long(productVersionId) });
1837: }
1838: }
1839:
1840: private SCFrameworkVersionPersistenceImpl _persistenceImpl;
1841: }
1842:
1843: protected class ClearSCProductVersions extends SqlUpdate {
1844: protected ClearSCProductVersions(
1845: SCFrameworkVersionPersistenceImpl persistenceImpl) {
1846: super (persistenceImpl.getDataSource(),
1847: "DELETE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ?");
1848:
1849: declareParameter(new SqlParameter(Types.BIGINT));
1850:
1851: compile();
1852: }
1853:
1854: protected void clear(long frameworkVersionId) {
1855: update(new Object[] { new Long(frameworkVersionId) });
1856: }
1857: }
1858:
1859: protected class RemoveSCProductVersion extends SqlUpdate {
1860: protected RemoveSCProductVersion(
1861: SCFrameworkVersionPersistenceImpl persistenceImpl) {
1862: super (
1863: persistenceImpl.getDataSource(),
1864: "DELETE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ? AND productVersionId = ?");
1865:
1866: declareParameter(new SqlParameter(Types.BIGINT));
1867: declareParameter(new SqlParameter(Types.BIGINT));
1868:
1869: compile();
1870: }
1871:
1872: protected void remove(long frameworkVersionId,
1873: long productVersionId) {
1874: update(new Object[] { new Long(frameworkVersionId),
1875: new Long(productVersionId) });
1876: }
1877: }
1878:
1879: private static ModelListener _getListener() {
1880: if (Validator.isNotNull(_LISTENER)) {
1881: try {
1882: return (ModelListener) Class.forName(_LISTENER)
1883: .newInstance();
1884: } catch (Exception e) {
1885: _log.error(e);
1886: }
1887: }
1888:
1889: return null;
1890: }
1891:
1892: private static final String _SQL_GETSCPRODUCTVERSIONS = "SELECT {SCProductVersion.*} FROM SCProductVersion INNER JOIN SCFrameworkVersi_SCProductVers ON (SCFrameworkVersi_SCProductVers.productVersionId = SCProductVersion.productVersionId) WHERE (SCFrameworkVersi_SCProductVers.frameworkVersionId = ?)";
1893: private static final String _SQL_GETSCPRODUCTVERSIONSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ?";
1894: private static final String _SQL_CONTAINSSCPRODUCTVERSION = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ? AND productVersionId = ?";
1895: private static final String _LISTENER = GetterUtil
1896: .getString(PropsUtil
1897: .get("value.object.listener.com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion"));
1898: private static Log _log = LogFactory
1899: .getLog(SCFrameworkVersionPersistenceImpl.class);
1900: }
|