1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.softwarecatalog.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.jdbc.MappingSqlQuery;
21  import com.liferay.portal.kernel.dao.jdbc.MappingSqlQueryFactoryUtil;
22  import com.liferay.portal.kernel.dao.jdbc.RowMapper;
23  import com.liferay.portal.kernel.dao.jdbc.SqlUpdate;
24  import com.liferay.portal.kernel.dao.jdbc.SqlUpdateFactoryUtil;
25  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
26  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
27  import com.liferay.portal.kernel.dao.orm.FinderPath;
28  import com.liferay.portal.kernel.dao.orm.Query;
29  import com.liferay.portal.kernel.dao.orm.QueryPos;
30  import com.liferay.portal.kernel.dao.orm.QueryUtil;
31  import com.liferay.portal.kernel.dao.orm.SQLQuery;
32  import com.liferay.portal.kernel.dao.orm.Session;
33  import com.liferay.portal.kernel.dao.orm.Type;
34  import com.liferay.portal.kernel.exception.SystemException;
35  import com.liferay.portal.kernel.log.Log;
36  import com.liferay.portal.kernel.log.LogFactoryUtil;
37  import com.liferay.portal.kernel.util.GetterUtil;
38  import com.liferay.portal.kernel.util.InstanceFactory;
39  import com.liferay.portal.kernel.util.OrderByComparator;
40  import com.liferay.portal.kernel.util.SetUtil;
41  import com.liferay.portal.kernel.util.StringBundler;
42  import com.liferay.portal.kernel.util.StringPool;
43  import com.liferay.portal.kernel.util.StringUtil;
44  import com.liferay.portal.model.ModelListener;
45  import com.liferay.portal.security.permission.InlineSQLHelperUtil;
46  import com.liferay.portal.service.persistence.BatchSessionUtil;
47  import com.liferay.portal.service.persistence.ResourcePersistence;
48  import com.liferay.portal.service.persistence.UserPersistence;
49  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
50  
51  import com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
52  import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion;
53  import com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionImpl;
54  import com.liferay.portlet.softwarecatalog.model.impl.SCFrameworkVersionModelImpl;
55  
56  import java.io.Serializable;
57  
58  import java.sql.Types;
59  
60  import java.util.ArrayList;
61  import java.util.Collections;
62  import java.util.List;
63  import java.util.Set;
64  
65  /**
66   * <a href="SCFrameworkVersionPersistenceImpl.java.html"><b><i>View Source</i></b></a>
67   *
68   * <p>
69   * ServiceBuilder generated this class. Modifications in this class will be
70   * overwritten the next time is generated.
71   * </p>
72   *
73   * @author    Brian Wing Shun Chan
74   * @see       SCFrameworkVersionPersistence
75   * @see       SCFrameworkVersionUtil
76   * @generated
77   */
78  public class SCFrameworkVersionPersistenceImpl extends BasePersistenceImpl<SCFrameworkVersion>
79      implements SCFrameworkVersionPersistence {
80      public static final String FINDER_CLASS_NAME_ENTITY = SCFrameworkVersionImpl.class.getName();
81      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
82          ".List";
83      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
84              SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "findByGroupId",
86              new String[] {
87                  Long.class.getName(),
88                  
89              "java.lang.Integer", "java.lang.Integer",
90                  "com.liferay.portal.kernel.util.OrderByComparator"
91              });
92      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
93              SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
94              FINDER_CLASS_NAME_LIST, "countByGroupId",
95              new String[] { Long.class.getName() });
96      public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
97              SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "findByCompanyId",
99              new String[] {
100                 Long.class.getName(),
101                 
102             "java.lang.Integer", "java.lang.Integer",
103                 "com.liferay.portal.kernel.util.OrderByComparator"
104             });
105     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
106             SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
107             FINDER_CLASS_NAME_LIST, "countByCompanyId",
108             new String[] { Long.class.getName() });
109     public static final FinderPath FINDER_PATH_FIND_BY_G_A = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
110             SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
111             FINDER_CLASS_NAME_LIST, "findByG_A",
112             new String[] {
113                 Long.class.getName(), Boolean.class.getName(),
114                 
115             "java.lang.Integer", "java.lang.Integer",
116                 "com.liferay.portal.kernel.util.OrderByComparator"
117             });
118     public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
119             SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
120             FINDER_CLASS_NAME_LIST, "countByG_A",
121             new String[] { Long.class.getName(), Boolean.class.getName() });
122     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
123             SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
124             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
125     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
126             SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED,
127             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
128 
129     public void cacheResult(SCFrameworkVersion scFrameworkVersion) {
130         EntityCacheUtil.putResult(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
131             SCFrameworkVersionImpl.class, scFrameworkVersion.getPrimaryKey(),
132             scFrameworkVersion);
133     }
134 
135     public void cacheResult(List<SCFrameworkVersion> scFrameworkVersions) {
136         for (SCFrameworkVersion scFrameworkVersion : scFrameworkVersions) {
137             if (EntityCacheUtil.getResult(
138                         SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
139                         SCFrameworkVersionImpl.class,
140                         scFrameworkVersion.getPrimaryKey(), this) == null) {
141                 cacheResult(scFrameworkVersion);
142             }
143         }
144     }
145 
146     public void clearCache() {
147         CacheRegistry.clear(SCFrameworkVersionImpl.class.getName());
148         EntityCacheUtil.clearCache(SCFrameworkVersionImpl.class.getName());
149         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
150         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
151     }
152 
153     public void clearCache(SCFrameworkVersion scFrameworkVersion) {
154         EntityCacheUtil.removeResult(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
155             SCFrameworkVersionImpl.class, scFrameworkVersion.getPrimaryKey());
156     }
157 
158     public SCFrameworkVersion create(long frameworkVersionId) {
159         SCFrameworkVersion scFrameworkVersion = new SCFrameworkVersionImpl();
160 
161         scFrameworkVersion.setNew(true);
162         scFrameworkVersion.setPrimaryKey(frameworkVersionId);
163 
164         return scFrameworkVersion;
165     }
166 
167     public SCFrameworkVersion remove(Serializable primaryKey)
168         throws NoSuchModelException, SystemException {
169         return remove(((Long)primaryKey).longValue());
170     }
171 
172     public SCFrameworkVersion remove(long frameworkVersionId)
173         throws NoSuchFrameworkVersionException, SystemException {
174         Session session = null;
175 
176         try {
177             session = openSession();
178 
179             SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion)session.get(SCFrameworkVersionImpl.class,
180                     new Long(frameworkVersionId));
181 
182             if (scFrameworkVersion == null) {
183                 if (_log.isWarnEnabled()) {
184                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
185                         frameworkVersionId);
186                 }
187 
188                 throw new NoSuchFrameworkVersionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
189                     frameworkVersionId);
190             }
191 
192             return remove(scFrameworkVersion);
193         }
194         catch (NoSuchFrameworkVersionException nsee) {
195             throw nsee;
196         }
197         catch (Exception e) {
198             throw processException(e);
199         }
200         finally {
201             closeSession(session);
202         }
203     }
204 
205     public SCFrameworkVersion remove(SCFrameworkVersion scFrameworkVersion)
206         throws SystemException {
207         for (ModelListener<SCFrameworkVersion> listener : listeners) {
208             listener.onBeforeRemove(scFrameworkVersion);
209         }
210 
211         scFrameworkVersion = removeImpl(scFrameworkVersion);
212 
213         for (ModelListener<SCFrameworkVersion> listener : listeners) {
214             listener.onAfterRemove(scFrameworkVersion);
215         }
216 
217         return scFrameworkVersion;
218     }
219 
220     protected SCFrameworkVersion removeImpl(
221         SCFrameworkVersion scFrameworkVersion) throws SystemException {
222         scFrameworkVersion = toUnwrappedModel(scFrameworkVersion);
223 
224         try {
225             clearSCProductVersions.clear(scFrameworkVersion.getPrimaryKey());
226         }
227         catch (Exception e) {
228             throw processException(e);
229         }
230         finally {
231             FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
232         }
233 
234         Session session = null;
235 
236         try {
237             session = openSession();
238 
239             if (scFrameworkVersion.isCachedModel() ||
240                     BatchSessionUtil.isEnabled()) {
241                 Object staleObject = session.get(SCFrameworkVersionImpl.class,
242                         scFrameworkVersion.getPrimaryKeyObj());
243 
244                 if (staleObject != null) {
245                     session.evict(staleObject);
246                 }
247             }
248 
249             session.delete(scFrameworkVersion);
250 
251             session.flush();
252         }
253         catch (Exception e) {
254             throw processException(e);
255         }
256         finally {
257             closeSession(session);
258         }
259 
260         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
261 
262         EntityCacheUtil.removeResult(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
263             SCFrameworkVersionImpl.class, scFrameworkVersion.getPrimaryKey());
264 
265         return scFrameworkVersion;
266     }
267 
268     public SCFrameworkVersion updateImpl(
269         com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion,
270         boolean merge) throws SystemException {
271         scFrameworkVersion = toUnwrappedModel(scFrameworkVersion);
272 
273         Session session = null;
274 
275         try {
276             session = openSession();
277 
278             BatchSessionUtil.update(session, scFrameworkVersion, merge);
279 
280             scFrameworkVersion.setNew(false);
281         }
282         catch (Exception e) {
283             throw processException(e);
284         }
285         finally {
286             closeSession(session);
287         }
288 
289         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
290 
291         EntityCacheUtil.putResult(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
292             SCFrameworkVersionImpl.class, scFrameworkVersion.getPrimaryKey(),
293             scFrameworkVersion);
294 
295         return scFrameworkVersion;
296     }
297 
298     protected SCFrameworkVersion toUnwrappedModel(
299         SCFrameworkVersion scFrameworkVersion) {
300         if (scFrameworkVersion instanceof SCFrameworkVersionImpl) {
301             return scFrameworkVersion;
302         }
303 
304         SCFrameworkVersionImpl scFrameworkVersionImpl = new SCFrameworkVersionImpl();
305 
306         scFrameworkVersionImpl.setNew(scFrameworkVersion.isNew());
307         scFrameworkVersionImpl.setPrimaryKey(scFrameworkVersion.getPrimaryKey());
308 
309         scFrameworkVersionImpl.setFrameworkVersionId(scFrameworkVersion.getFrameworkVersionId());
310         scFrameworkVersionImpl.setGroupId(scFrameworkVersion.getGroupId());
311         scFrameworkVersionImpl.setCompanyId(scFrameworkVersion.getCompanyId());
312         scFrameworkVersionImpl.setUserId(scFrameworkVersion.getUserId());
313         scFrameworkVersionImpl.setUserName(scFrameworkVersion.getUserName());
314         scFrameworkVersionImpl.setCreateDate(scFrameworkVersion.getCreateDate());
315         scFrameworkVersionImpl.setModifiedDate(scFrameworkVersion.getModifiedDate());
316         scFrameworkVersionImpl.setName(scFrameworkVersion.getName());
317         scFrameworkVersionImpl.setUrl(scFrameworkVersion.getUrl());
318         scFrameworkVersionImpl.setActive(scFrameworkVersion.isActive());
319         scFrameworkVersionImpl.setPriority(scFrameworkVersion.getPriority());
320 
321         return scFrameworkVersionImpl;
322     }
323 
324     public SCFrameworkVersion findByPrimaryKey(Serializable primaryKey)
325         throws NoSuchModelException, SystemException {
326         return findByPrimaryKey(((Long)primaryKey).longValue());
327     }
328 
329     public SCFrameworkVersion findByPrimaryKey(long frameworkVersionId)
330         throws NoSuchFrameworkVersionException, SystemException {
331         SCFrameworkVersion scFrameworkVersion = fetchByPrimaryKey(frameworkVersionId);
332 
333         if (scFrameworkVersion == null) {
334             if (_log.isWarnEnabled()) {
335                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
336                     frameworkVersionId);
337             }
338 
339             throw new NoSuchFrameworkVersionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
340                 frameworkVersionId);
341         }
342 
343         return scFrameworkVersion;
344     }
345 
346     public SCFrameworkVersion fetchByPrimaryKey(Serializable primaryKey)
347         throws SystemException {
348         return fetchByPrimaryKey(((Long)primaryKey).longValue());
349     }
350 
351     public SCFrameworkVersion fetchByPrimaryKey(long frameworkVersionId)
352         throws SystemException {
353         SCFrameworkVersion scFrameworkVersion = (SCFrameworkVersion)EntityCacheUtil.getResult(SCFrameworkVersionModelImpl.ENTITY_CACHE_ENABLED,
354                 SCFrameworkVersionImpl.class, frameworkVersionId, this);
355 
356         if (scFrameworkVersion == null) {
357             Session session = null;
358 
359             try {
360                 session = openSession();
361 
362                 scFrameworkVersion = (SCFrameworkVersion)session.get(SCFrameworkVersionImpl.class,
363                         new Long(frameworkVersionId));
364             }
365             catch (Exception e) {
366                 throw processException(e);
367             }
368             finally {
369                 if (scFrameworkVersion != null) {
370                     cacheResult(scFrameworkVersion);
371                 }
372 
373                 closeSession(session);
374             }
375         }
376 
377         return scFrameworkVersion;
378     }
379 
380     public List<SCFrameworkVersion> findByGroupId(long groupId)
381         throws SystemException {
382         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
383     }
384 
385     public List<SCFrameworkVersion> findByGroupId(long groupId, int start,
386         int end) throws SystemException {
387         return findByGroupId(groupId, start, end, null);
388     }
389 
390     public List<SCFrameworkVersion> findByGroupId(long groupId, int start,
391         int end, OrderByComparator orderByComparator) throws SystemException {
392         Object[] finderArgs = new Object[] {
393                 new Long(groupId),
394                 
395                 String.valueOf(start), String.valueOf(end),
396                 String.valueOf(orderByComparator)
397             };
398 
399         List<SCFrameworkVersion> list = (List<SCFrameworkVersion>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
400                 finderArgs, this);
401 
402         if (list == null) {
403             Session session = null;
404 
405             try {
406                 session = openSession();
407 
408                 StringBundler query = null;
409 
410                 if (orderByComparator != null) {
411                     query = new StringBundler(3 +
412                             (orderByComparator.getOrderByFields().length * 3));
413                 }
414                 else {
415                     query = new StringBundler(3);
416                 }
417 
418                 query.append(_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
419 
420                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
421 
422                 if (orderByComparator != null) {
423                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
424                         orderByComparator);
425                 }
426 
427                 else {
428                     query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
429                 }
430 
431                 String sql = query.toString();
432 
433                 Query q = session.createQuery(sql);
434 
435                 QueryPos qPos = QueryPos.getInstance(q);
436 
437                 qPos.add(groupId);
438 
439                 list = (List<SCFrameworkVersion>)QueryUtil.list(q,
440                         getDialect(), start, end);
441             }
442             catch (Exception e) {
443                 throw processException(e);
444             }
445             finally {
446                 if (list == null) {
447                     list = new ArrayList<SCFrameworkVersion>();
448                 }
449 
450                 cacheResult(list);
451 
452                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
453                     finderArgs, list);
454 
455                 closeSession(session);
456             }
457         }
458 
459         return list;
460     }
461 
462     public SCFrameworkVersion findByGroupId_First(long groupId,
463         OrderByComparator orderByComparator)
464         throws NoSuchFrameworkVersionException, SystemException {
465         List<SCFrameworkVersion> list = findByGroupId(groupId, 0, 1,
466                 orderByComparator);
467 
468         if (list.isEmpty()) {
469             StringBundler msg = new StringBundler(4);
470 
471             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
472 
473             msg.append("groupId=");
474             msg.append(groupId);
475 
476             msg.append(StringPool.CLOSE_CURLY_BRACE);
477 
478             throw new NoSuchFrameworkVersionException(msg.toString());
479         }
480         else {
481             return list.get(0);
482         }
483     }
484 
485     public SCFrameworkVersion findByGroupId_Last(long groupId,
486         OrderByComparator orderByComparator)
487         throws NoSuchFrameworkVersionException, SystemException {
488         int count = countByGroupId(groupId);
489 
490         List<SCFrameworkVersion> list = findByGroupId(groupId, count - 1,
491                 count, orderByComparator);
492 
493         if (list.isEmpty()) {
494             StringBundler msg = new StringBundler(4);
495 
496             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
497 
498             msg.append("groupId=");
499             msg.append(groupId);
500 
501             msg.append(StringPool.CLOSE_CURLY_BRACE);
502 
503             throw new NoSuchFrameworkVersionException(msg.toString());
504         }
505         else {
506             return list.get(0);
507         }
508     }
509 
510     public SCFrameworkVersion[] findByGroupId_PrevAndNext(
511         long frameworkVersionId, long groupId,
512         OrderByComparator orderByComparator)
513         throws NoSuchFrameworkVersionException, SystemException {
514         SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
515 
516         Session session = null;
517 
518         try {
519             session = openSession();
520 
521             SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
522 
523             array[0] = getByGroupId_PrevAndNext(session, scFrameworkVersion,
524                     groupId, orderByComparator, true);
525 
526             array[1] = scFrameworkVersion;
527 
528             array[2] = getByGroupId_PrevAndNext(session, scFrameworkVersion,
529                     groupId, orderByComparator, false);
530 
531             return array;
532         }
533         catch (Exception e) {
534             throw processException(e);
535         }
536         finally {
537             closeSession(session);
538         }
539     }
540 
541     protected SCFrameworkVersion getByGroupId_PrevAndNext(Session session,
542         SCFrameworkVersion scFrameworkVersion, long groupId,
543         OrderByComparator orderByComparator, boolean previous) {
544         StringBundler query = null;
545 
546         if (orderByComparator != null) {
547             query = new StringBundler(6 +
548                     (orderByComparator.getOrderByFields().length * 6));
549         }
550         else {
551             query = new StringBundler(3);
552         }
553 
554         query.append(_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
555 
556         query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
557 
558         if (orderByComparator != null) {
559             String[] orderByFields = orderByComparator.getOrderByFields();
560 
561             if (orderByFields.length > 0) {
562                 query.append(WHERE_AND);
563             }
564 
565             for (int i = 0; i < orderByFields.length; i++) {
566                 query.append(_ORDER_BY_ENTITY_ALIAS);
567                 query.append(orderByFields[i]);
568 
569                 if ((i + 1) < orderByFields.length) {
570                     if (orderByComparator.isAscending() ^ previous) {
571                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
572                     }
573                     else {
574                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
575                     }
576                 }
577                 else {
578                     if (orderByComparator.isAscending() ^ previous) {
579                         query.append(WHERE_GREATER_THAN);
580                     }
581                     else {
582                         query.append(WHERE_LESSER_THAN);
583                     }
584                 }
585             }
586 
587             query.append(ORDER_BY_CLAUSE);
588 
589             for (int i = 0; i < orderByFields.length; i++) {
590                 query.append(_ORDER_BY_ENTITY_ALIAS);
591                 query.append(orderByFields[i]);
592 
593                 if ((i + 1) < orderByFields.length) {
594                     if (orderByComparator.isAscending() ^ previous) {
595                         query.append(ORDER_BY_ASC_HAS_NEXT);
596                     }
597                     else {
598                         query.append(ORDER_BY_DESC_HAS_NEXT);
599                     }
600                 }
601                 else {
602                     if (orderByComparator.isAscending() ^ previous) {
603                         query.append(ORDER_BY_ASC);
604                     }
605                     else {
606                         query.append(ORDER_BY_DESC);
607                     }
608                 }
609             }
610         }
611 
612         else {
613             query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
614         }
615 
616         String sql = query.toString();
617 
618         Query q = session.createQuery(sql);
619 
620         q.setFirstResult(0);
621         q.setMaxResults(2);
622 
623         QueryPos qPos = QueryPos.getInstance(q);
624 
625         qPos.add(groupId);
626 
627         if (orderByComparator != null) {
628             Object[] values = orderByComparator.getOrderByValues(scFrameworkVersion);
629 
630             for (Object value : values) {
631                 qPos.add(value);
632             }
633         }
634 
635         List<SCFrameworkVersion> list = q.list();
636 
637         if (list.size() == 2) {
638             return list.get(1);
639         }
640         else {
641             return null;
642         }
643     }
644 
645     public List<SCFrameworkVersion> filterFindByGroupId(long groupId)
646         throws SystemException {
647         return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
648             QueryUtil.ALL_POS, null);
649     }
650 
651     public List<SCFrameworkVersion> filterFindByGroupId(long groupId,
652         int start, int end) throws SystemException {
653         return filterFindByGroupId(groupId, start, end, null);
654     }
655 
656     public List<SCFrameworkVersion> filterFindByGroupId(long groupId,
657         int start, int end, OrderByComparator orderByComparator)
658         throws SystemException {
659         if (!InlineSQLHelperUtil.isEnabled(groupId)) {
660             return findByGroupId(groupId, start, end, orderByComparator);
661         }
662 
663         Session session = null;
664 
665         try {
666             session = openSession();
667 
668             StringBundler query = null;
669 
670             if (orderByComparator != null) {
671                 query = new StringBundler(3 +
672                         (orderByComparator.getOrderByFields().length * 3));
673             }
674             else {
675                 query = new StringBundler(3);
676             }
677 
678             query.append(_FILTER_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
679 
680             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
681 
682             if (orderByComparator != null) {
683                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
684                     orderByComparator);
685             }
686 
687             else {
688                 query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
689             }
690 
691             String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
692                     SCFrameworkVersion.class.getName(),
693                     _FILTER_COLUMN_FRAMEWORKVERSIONID, _FILTER_COLUMN_USERID,
694                     groupId);
695 
696             SQLQuery q = session.createSQLQuery(sql);
697 
698             q.addEntity(_FILTER_ENTITY_ALIAS, SCFrameworkVersionImpl.class);
699 
700             QueryPos qPos = QueryPos.getInstance(q);
701 
702             qPos.add(groupId);
703 
704             return (List<SCFrameworkVersion>)QueryUtil.list(q, getDialect(),
705                 start, end);
706         }
707         catch (Exception e) {
708             throw processException(e);
709         }
710         finally {
711             closeSession(session);
712         }
713     }
714 
715     public List<SCFrameworkVersion> findByCompanyId(long companyId)
716         throws SystemException {
717         return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
718             null);
719     }
720 
721     public List<SCFrameworkVersion> findByCompanyId(long companyId, int start,
722         int end) throws SystemException {
723         return findByCompanyId(companyId, start, end, null);
724     }
725 
726     public List<SCFrameworkVersion> findByCompanyId(long companyId, int start,
727         int end, OrderByComparator orderByComparator) throws SystemException {
728         Object[] finderArgs = new Object[] {
729                 new Long(companyId),
730                 
731                 String.valueOf(start), String.valueOf(end),
732                 String.valueOf(orderByComparator)
733             };
734 
735         List<SCFrameworkVersion> list = (List<SCFrameworkVersion>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
736                 finderArgs, this);
737 
738         if (list == null) {
739             Session session = null;
740 
741             try {
742                 session = openSession();
743 
744                 StringBundler query = null;
745 
746                 if (orderByComparator != null) {
747                     query = new StringBundler(3 +
748                             (orderByComparator.getOrderByFields().length * 3));
749                 }
750                 else {
751                     query = new StringBundler(3);
752                 }
753 
754                 query.append(_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
755 
756                 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
757 
758                 if (orderByComparator != null) {
759                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
760                         orderByComparator);
761                 }
762 
763                 else {
764                     query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
765                 }
766 
767                 String sql = query.toString();
768 
769                 Query q = session.createQuery(sql);
770 
771                 QueryPos qPos = QueryPos.getInstance(q);
772 
773                 qPos.add(companyId);
774 
775                 list = (List<SCFrameworkVersion>)QueryUtil.list(q,
776                         getDialect(), start, end);
777             }
778             catch (Exception e) {
779                 throw processException(e);
780             }
781             finally {
782                 if (list == null) {
783                     list = new ArrayList<SCFrameworkVersion>();
784                 }
785 
786                 cacheResult(list);
787 
788                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
789                     finderArgs, list);
790 
791                 closeSession(session);
792             }
793         }
794 
795         return list;
796     }
797 
798     public SCFrameworkVersion findByCompanyId_First(long companyId,
799         OrderByComparator orderByComparator)
800         throws NoSuchFrameworkVersionException, SystemException {
801         List<SCFrameworkVersion> list = findByCompanyId(companyId, 0, 1,
802                 orderByComparator);
803 
804         if (list.isEmpty()) {
805             StringBundler msg = new StringBundler(4);
806 
807             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
808 
809             msg.append("companyId=");
810             msg.append(companyId);
811 
812             msg.append(StringPool.CLOSE_CURLY_BRACE);
813 
814             throw new NoSuchFrameworkVersionException(msg.toString());
815         }
816         else {
817             return list.get(0);
818         }
819     }
820 
821     public SCFrameworkVersion findByCompanyId_Last(long companyId,
822         OrderByComparator orderByComparator)
823         throws NoSuchFrameworkVersionException, SystemException {
824         int count = countByCompanyId(companyId);
825 
826         List<SCFrameworkVersion> list = findByCompanyId(companyId, count - 1,
827                 count, orderByComparator);
828 
829         if (list.isEmpty()) {
830             StringBundler msg = new StringBundler(4);
831 
832             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
833 
834             msg.append("companyId=");
835             msg.append(companyId);
836 
837             msg.append(StringPool.CLOSE_CURLY_BRACE);
838 
839             throw new NoSuchFrameworkVersionException(msg.toString());
840         }
841         else {
842             return list.get(0);
843         }
844     }
845 
846     public SCFrameworkVersion[] findByCompanyId_PrevAndNext(
847         long frameworkVersionId, long companyId,
848         OrderByComparator orderByComparator)
849         throws NoSuchFrameworkVersionException, SystemException {
850         SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
851 
852         Session session = null;
853 
854         try {
855             session = openSession();
856 
857             SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
858 
859             array[0] = getByCompanyId_PrevAndNext(session, scFrameworkVersion,
860                     companyId, orderByComparator, true);
861 
862             array[1] = scFrameworkVersion;
863 
864             array[2] = getByCompanyId_PrevAndNext(session, scFrameworkVersion,
865                     companyId, orderByComparator, false);
866 
867             return array;
868         }
869         catch (Exception e) {
870             throw processException(e);
871         }
872         finally {
873             closeSession(session);
874         }
875     }
876 
877     protected SCFrameworkVersion getByCompanyId_PrevAndNext(Session session,
878         SCFrameworkVersion scFrameworkVersion, long companyId,
879         OrderByComparator orderByComparator, boolean previous) {
880         StringBundler query = null;
881 
882         if (orderByComparator != null) {
883             query = new StringBundler(6 +
884                     (orderByComparator.getOrderByFields().length * 6));
885         }
886         else {
887             query = new StringBundler(3);
888         }
889 
890         query.append(_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
891 
892         query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
893 
894         if (orderByComparator != null) {
895             String[] orderByFields = orderByComparator.getOrderByFields();
896 
897             if (orderByFields.length > 0) {
898                 query.append(WHERE_AND);
899             }
900 
901             for (int i = 0; i < orderByFields.length; i++) {
902                 query.append(_ORDER_BY_ENTITY_ALIAS);
903                 query.append(orderByFields[i]);
904 
905                 if ((i + 1) < orderByFields.length) {
906                     if (orderByComparator.isAscending() ^ previous) {
907                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
908                     }
909                     else {
910                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
911                     }
912                 }
913                 else {
914                     if (orderByComparator.isAscending() ^ previous) {
915                         query.append(WHERE_GREATER_THAN);
916                     }
917                     else {
918                         query.append(WHERE_LESSER_THAN);
919                     }
920                 }
921             }
922 
923             query.append(ORDER_BY_CLAUSE);
924 
925             for (int i = 0; i < orderByFields.length; i++) {
926                 query.append(_ORDER_BY_ENTITY_ALIAS);
927                 query.append(orderByFields[i]);
928 
929                 if ((i + 1) < orderByFields.length) {
930                     if (orderByComparator.isAscending() ^ previous) {
931                         query.append(ORDER_BY_ASC_HAS_NEXT);
932                     }
933                     else {
934                         query.append(ORDER_BY_DESC_HAS_NEXT);
935                     }
936                 }
937                 else {
938                     if (orderByComparator.isAscending() ^ previous) {
939                         query.append(ORDER_BY_ASC);
940                     }
941                     else {
942                         query.append(ORDER_BY_DESC);
943                     }
944                 }
945             }
946         }
947 
948         else {
949             query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
950         }
951 
952         String sql = query.toString();
953 
954         Query q = session.createQuery(sql);
955 
956         q.setFirstResult(0);
957         q.setMaxResults(2);
958 
959         QueryPos qPos = QueryPos.getInstance(q);
960 
961         qPos.add(companyId);
962 
963         if (orderByComparator != null) {
964             Object[] values = orderByComparator.getOrderByValues(scFrameworkVersion);
965 
966             for (Object value : values) {
967                 qPos.add(value);
968             }
969         }
970 
971         List<SCFrameworkVersion> list = q.list();
972 
973         if (list.size() == 2) {
974             return list.get(1);
975         }
976         else {
977             return null;
978         }
979     }
980 
981     public List<SCFrameworkVersion> findByG_A(long groupId, boolean active)
982         throws SystemException {
983         return findByG_A(groupId, active, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
984             null);
985     }
986 
987     public List<SCFrameworkVersion> findByG_A(long groupId, boolean active,
988         int start, int end) throws SystemException {
989         return findByG_A(groupId, active, start, end, null);
990     }
991 
992     public List<SCFrameworkVersion> findByG_A(long groupId, boolean active,
993         int start, int end, OrderByComparator orderByComparator)
994         throws SystemException {
995         Object[] finderArgs = new Object[] {
996                 new Long(groupId), Boolean.valueOf(active),
997                 
998                 String.valueOf(start), String.valueOf(end),
999                 String.valueOf(orderByComparator)
1000            };
1001
1002        List<SCFrameworkVersion> list = (List<SCFrameworkVersion>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A,
1003                finderArgs, this);
1004
1005        if (list == null) {
1006            Session session = null;
1007
1008            try {
1009                session = openSession();
1010
1011                StringBundler query = null;
1012
1013                if (orderByComparator != null) {
1014                    query = new StringBundler(4 +
1015                            (orderByComparator.getOrderByFields().length * 3));
1016                }
1017                else {
1018                    query = new StringBundler(4);
1019                }
1020
1021                query.append(_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
1022
1023                query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1024
1025                query.append(_FINDER_COLUMN_G_A_ACTIVE_2);
1026
1027                if (orderByComparator != null) {
1028                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1029                        orderByComparator);
1030                }
1031
1032                else {
1033                    query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
1034                }
1035
1036                String sql = query.toString();
1037
1038                Query q = session.createQuery(sql);
1039
1040                QueryPos qPos = QueryPos.getInstance(q);
1041
1042                qPos.add(groupId);
1043
1044                qPos.add(active);
1045
1046                list = (List<SCFrameworkVersion>)QueryUtil.list(q,
1047                        getDialect(), start, end);
1048            }
1049            catch (Exception e) {
1050                throw processException(e);
1051            }
1052            finally {
1053                if (list == null) {
1054                    list = new ArrayList<SCFrameworkVersion>();
1055                }
1056
1057                cacheResult(list);
1058
1059                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A, finderArgs,
1060                    list);
1061
1062                closeSession(session);
1063            }
1064        }
1065
1066        return list;
1067    }
1068
1069    public SCFrameworkVersion findByG_A_First(long groupId, boolean active,
1070        OrderByComparator orderByComparator)
1071        throws NoSuchFrameworkVersionException, SystemException {
1072        List<SCFrameworkVersion> list = findByG_A(groupId, active, 0, 1,
1073                orderByComparator);
1074
1075        if (list.isEmpty()) {
1076            StringBundler msg = new StringBundler(6);
1077
1078            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1079
1080            msg.append("groupId=");
1081            msg.append(groupId);
1082
1083            msg.append(", active=");
1084            msg.append(active);
1085
1086            msg.append(StringPool.CLOSE_CURLY_BRACE);
1087
1088            throw new NoSuchFrameworkVersionException(msg.toString());
1089        }
1090        else {
1091            return list.get(0);
1092        }
1093    }
1094
1095    public SCFrameworkVersion findByG_A_Last(long groupId, boolean active,
1096        OrderByComparator orderByComparator)
1097        throws NoSuchFrameworkVersionException, SystemException {
1098        int count = countByG_A(groupId, active);
1099
1100        List<SCFrameworkVersion> list = findByG_A(groupId, active, count - 1,
1101                count, orderByComparator);
1102
1103        if (list.isEmpty()) {
1104            StringBundler msg = new StringBundler(6);
1105
1106            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1107
1108            msg.append("groupId=");
1109            msg.append(groupId);
1110
1111            msg.append(", active=");
1112            msg.append(active);
1113
1114            msg.append(StringPool.CLOSE_CURLY_BRACE);
1115
1116            throw new NoSuchFrameworkVersionException(msg.toString());
1117        }
1118        else {
1119            return list.get(0);
1120        }
1121    }
1122
1123    public SCFrameworkVersion[] findByG_A_PrevAndNext(long frameworkVersionId,
1124        long groupId, boolean active, OrderByComparator orderByComparator)
1125        throws NoSuchFrameworkVersionException, SystemException {
1126        SCFrameworkVersion scFrameworkVersion = findByPrimaryKey(frameworkVersionId);
1127
1128        Session session = null;
1129
1130        try {
1131            session = openSession();
1132
1133            SCFrameworkVersion[] array = new SCFrameworkVersionImpl[3];
1134
1135            array[0] = getByG_A_PrevAndNext(session, scFrameworkVersion,
1136                    groupId, active, orderByComparator, true);
1137
1138            array[1] = scFrameworkVersion;
1139
1140            array[2] = getByG_A_PrevAndNext(session, scFrameworkVersion,
1141                    groupId, active, orderByComparator, false);
1142
1143            return array;
1144        }
1145        catch (Exception e) {
1146            throw processException(e);
1147        }
1148        finally {
1149            closeSession(session);
1150        }
1151    }
1152
1153    protected SCFrameworkVersion getByG_A_PrevAndNext(Session session,
1154        SCFrameworkVersion scFrameworkVersion, long groupId, boolean active,
1155        OrderByComparator orderByComparator, boolean previous) {
1156        StringBundler query = null;
1157
1158        if (orderByComparator != null) {
1159            query = new StringBundler(6 +
1160                    (orderByComparator.getOrderByFields().length * 6));
1161        }
1162        else {
1163            query = new StringBundler(3);
1164        }
1165
1166        query.append(_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
1167
1168        query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1169
1170        query.append(_FINDER_COLUMN_G_A_ACTIVE_2);
1171
1172        if (orderByComparator != null) {
1173            String[] orderByFields = orderByComparator.getOrderByFields();
1174
1175            if (orderByFields.length > 0) {
1176                query.append(WHERE_AND);
1177            }
1178
1179            for (int i = 0; i < orderByFields.length; i++) {
1180                query.append(_ORDER_BY_ENTITY_ALIAS);
1181                query.append(orderByFields[i]);
1182
1183                if ((i + 1) < orderByFields.length) {
1184                    if (orderByComparator.isAscending() ^ previous) {
1185                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1186                    }
1187                    else {
1188                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1189                    }
1190                }
1191                else {
1192                    if (orderByComparator.isAscending() ^ previous) {
1193                        query.append(WHERE_GREATER_THAN);
1194                    }
1195                    else {
1196                        query.append(WHERE_LESSER_THAN);
1197                    }
1198                }
1199            }
1200
1201            query.append(ORDER_BY_CLAUSE);
1202
1203            for (int i = 0; i < orderByFields.length; i++) {
1204                query.append(_ORDER_BY_ENTITY_ALIAS);
1205                query.append(orderByFields[i]);
1206
1207                if ((i + 1) < orderByFields.length) {
1208                    if (orderByComparator.isAscending() ^ previous) {
1209                        query.append(ORDER_BY_ASC_HAS_NEXT);
1210                    }
1211                    else {
1212                        query.append(ORDER_BY_DESC_HAS_NEXT);
1213                    }
1214                }
1215                else {
1216                    if (orderByComparator.isAscending() ^ previous) {
1217                        query.append(ORDER_BY_ASC);
1218                    }
1219                    else {
1220                        query.append(ORDER_BY_DESC);
1221                    }
1222                }
1223            }
1224        }
1225
1226        else {
1227            query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
1228        }
1229
1230        String sql = query.toString();
1231
1232        Query q = session.createQuery(sql);
1233
1234        q.setFirstResult(0);
1235        q.setMaxResults(2);
1236
1237        QueryPos qPos = QueryPos.getInstance(q);
1238
1239        qPos.add(groupId);
1240
1241        qPos.add(active);
1242
1243        if (orderByComparator != null) {
1244            Object[] values = orderByComparator.getOrderByValues(scFrameworkVersion);
1245
1246            for (Object value : values) {
1247                qPos.add(value);
1248            }
1249        }
1250
1251        List<SCFrameworkVersion> list = q.list();
1252
1253        if (list.size() == 2) {
1254            return list.get(1);
1255        }
1256        else {
1257            return null;
1258        }
1259    }
1260
1261    public List<SCFrameworkVersion> filterFindByG_A(long groupId, boolean active)
1262        throws SystemException {
1263        return filterFindByG_A(groupId, active, QueryUtil.ALL_POS,
1264            QueryUtil.ALL_POS, null);
1265    }
1266
1267    public List<SCFrameworkVersion> filterFindByG_A(long groupId,
1268        boolean active, int start, int end) throws SystemException {
1269        return filterFindByG_A(groupId, active, start, end, null);
1270    }
1271
1272    public List<SCFrameworkVersion> filterFindByG_A(long groupId,
1273        boolean active, int start, int end, OrderByComparator orderByComparator)
1274        throws SystemException {
1275        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1276            return findByG_A(groupId, active, start, end, orderByComparator);
1277        }
1278
1279        Session session = null;
1280
1281        try {
1282            session = openSession();
1283
1284            StringBundler query = null;
1285
1286            if (orderByComparator != null) {
1287                query = new StringBundler(4 +
1288                        (orderByComparator.getOrderByFields().length * 3));
1289            }
1290            else {
1291                query = new StringBundler(4);
1292            }
1293
1294            query.append(_FILTER_SQL_SELECT_SCFRAMEWORKVERSION_WHERE);
1295
1296            query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1297
1298            query.append(_FINDER_COLUMN_G_A_ACTIVE_2);
1299
1300            if (orderByComparator != null) {
1301                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1302                    orderByComparator);
1303            }
1304
1305            else {
1306                query.append(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
1307            }
1308
1309            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1310                    SCFrameworkVersion.class.getName(),
1311                    _FILTER_COLUMN_FRAMEWORKVERSIONID, _FILTER_COLUMN_USERID,
1312                    groupId);
1313
1314            SQLQuery q = session.createSQLQuery(sql);
1315
1316            q.addEntity(_FILTER_ENTITY_ALIAS, SCFrameworkVersionImpl.class);
1317
1318            QueryPos qPos = QueryPos.getInstance(q);
1319
1320            qPos.add(groupId);
1321
1322            qPos.add(active);
1323
1324            return (List<SCFrameworkVersion>)QueryUtil.list(q, getDialect(),
1325                start, end);
1326        }
1327        catch (Exception e) {
1328            throw processException(e);
1329        }
1330        finally {
1331            closeSession(session);
1332        }
1333    }
1334
1335    public List<SCFrameworkVersion> findAll() throws SystemException {
1336        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1337    }
1338
1339    public List<SCFrameworkVersion> findAll(int start, int end)
1340        throws SystemException {
1341        return findAll(start, end, null);
1342    }
1343
1344    public List<SCFrameworkVersion> findAll(int start, int end,
1345        OrderByComparator orderByComparator) throws SystemException {
1346        Object[] finderArgs = new Object[] {
1347                String.valueOf(start), String.valueOf(end),
1348                String.valueOf(orderByComparator)
1349            };
1350
1351        List<SCFrameworkVersion> list = (List<SCFrameworkVersion>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1352                finderArgs, this);
1353
1354        if (list == null) {
1355            Session session = null;
1356
1357            try {
1358                session = openSession();
1359
1360                StringBundler query = null;
1361                String sql = null;
1362
1363                if (orderByComparator != null) {
1364                    query = new StringBundler(2 +
1365                            (orderByComparator.getOrderByFields().length * 3));
1366
1367                    query.append(_SQL_SELECT_SCFRAMEWORKVERSION);
1368
1369                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1370                        orderByComparator);
1371
1372                    sql = query.toString();
1373                }
1374
1375                else {
1376                    sql = _SQL_SELECT_SCFRAMEWORKVERSION.concat(SCFrameworkVersionModelImpl.ORDER_BY_JPQL);
1377                }
1378
1379                Query q = session.createQuery(sql);
1380
1381                if (orderByComparator == null) {
1382                    list = (List<SCFrameworkVersion>)QueryUtil.list(q,
1383                            getDialect(), start, end, false);
1384
1385                    Collections.sort(list);
1386                }
1387                else {
1388                    list = (List<SCFrameworkVersion>)QueryUtil.list(q,
1389                            getDialect(), start, end);
1390                }
1391            }
1392            catch (Exception e) {
1393                throw processException(e);
1394            }
1395            finally {
1396                if (list == null) {
1397                    list = new ArrayList<SCFrameworkVersion>();
1398                }
1399
1400                cacheResult(list);
1401
1402                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1403
1404                closeSession(session);
1405            }
1406        }
1407
1408        return list;
1409    }
1410
1411    public void removeByGroupId(long groupId) throws SystemException {
1412        for (SCFrameworkVersion scFrameworkVersion : findByGroupId(groupId)) {
1413            remove(scFrameworkVersion);
1414        }
1415    }
1416
1417    public void removeByCompanyId(long companyId) throws SystemException {
1418        for (SCFrameworkVersion scFrameworkVersion : findByCompanyId(companyId)) {
1419            remove(scFrameworkVersion);
1420        }
1421    }
1422
1423    public void removeByG_A(long groupId, boolean active)
1424        throws SystemException {
1425        for (SCFrameworkVersion scFrameworkVersion : findByG_A(groupId, active)) {
1426            remove(scFrameworkVersion);
1427        }
1428    }
1429
1430    public void removeAll() throws SystemException {
1431        for (SCFrameworkVersion scFrameworkVersion : findAll()) {
1432            remove(scFrameworkVersion);
1433        }
1434    }
1435
1436    public int countByGroupId(long groupId) throws SystemException {
1437        Object[] finderArgs = new Object[] { new Long(groupId) };
1438
1439        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1440                finderArgs, this);
1441
1442        if (count == null) {
1443            Session session = null;
1444
1445            try {
1446                session = openSession();
1447
1448                StringBundler query = new StringBundler(2);
1449
1450                query.append(_SQL_COUNT_SCFRAMEWORKVERSION_WHERE);
1451
1452                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1453
1454                String sql = query.toString();
1455
1456                Query q = session.createQuery(sql);
1457
1458                QueryPos qPos = QueryPos.getInstance(q);
1459
1460                qPos.add(groupId);
1461
1462                count = (Long)q.uniqueResult();
1463            }
1464            catch (Exception e) {
1465                throw processException(e);
1466            }
1467            finally {
1468                if (count == null) {
1469                    count = Long.valueOf(0);
1470                }
1471
1472                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1473                    finderArgs, count);
1474
1475                closeSession(session);
1476            }
1477        }
1478
1479        return count.intValue();
1480    }
1481
1482    public int filterCountByGroupId(long groupId) throws SystemException {
1483        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1484            return countByGroupId(groupId);
1485        }
1486
1487        Session session = null;
1488
1489        try {
1490            session = openSession();
1491
1492            StringBundler query = new StringBundler(2);
1493
1494            query.append(_FILTER_SQL_COUNT_SCFRAMEWORKVERSION_WHERE);
1495
1496            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1497
1498            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1499                    SCFrameworkVersion.class.getName(),
1500                    _FILTER_COLUMN_FRAMEWORKVERSIONID, _FILTER_COLUMN_USERID,
1501                    groupId);
1502
1503            SQLQuery q = session.createSQLQuery(sql);
1504
1505            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1506
1507            QueryPos qPos = QueryPos.getInstance(q);
1508
1509            qPos.add(groupId);
1510
1511            Long count = (Long)q.uniqueResult();
1512
1513            return count.intValue();
1514        }
1515        catch (Exception e) {
1516            throw processException(e);
1517        }
1518        finally {
1519            closeSession(session);
1520        }
1521    }
1522
1523    public int countByCompanyId(long companyId) throws SystemException {
1524        Object[] finderArgs = new Object[] { new Long(companyId) };
1525
1526        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
1527                finderArgs, this);
1528
1529        if (count == null) {
1530            Session session = null;
1531
1532            try {
1533                session = openSession();
1534
1535                StringBundler query = new StringBundler(2);
1536
1537                query.append(_SQL_COUNT_SCFRAMEWORKVERSION_WHERE);
1538
1539                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1540
1541                String sql = query.toString();
1542
1543                Query q = session.createQuery(sql);
1544
1545                QueryPos qPos = QueryPos.getInstance(q);
1546
1547                qPos.add(companyId);
1548
1549                count = (Long)q.uniqueResult();
1550            }
1551            catch (Exception e) {
1552                throw processException(e);
1553            }
1554            finally {
1555                if (count == null) {
1556                    count = Long.valueOf(0);
1557                }
1558
1559                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
1560                    finderArgs, count);
1561
1562                closeSession(session);
1563            }
1564        }
1565
1566        return count.intValue();
1567    }
1568
1569    public int countByG_A(long groupId, boolean active)
1570        throws SystemException {
1571        Object[] finderArgs = new Object[] {
1572                new Long(groupId), Boolean.valueOf(active)
1573            };
1574
1575        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
1576                finderArgs, this);
1577
1578        if (count == null) {
1579            Session session = null;
1580
1581            try {
1582                session = openSession();
1583
1584                StringBundler query = new StringBundler(3);
1585
1586                query.append(_SQL_COUNT_SCFRAMEWORKVERSION_WHERE);
1587
1588                query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1589
1590                query.append(_FINDER_COLUMN_G_A_ACTIVE_2);
1591
1592                String sql = query.toString();
1593
1594                Query q = session.createQuery(sql);
1595
1596                QueryPos qPos = QueryPos.getInstance(q);
1597
1598                qPos.add(groupId);
1599
1600                qPos.add(active);
1601
1602                count = (Long)q.uniqueResult();
1603            }
1604            catch (Exception e) {
1605                throw processException(e);
1606            }
1607            finally {
1608                if (count == null) {
1609                    count = Long.valueOf(0);
1610                }
1611
1612                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
1613                    count);
1614
1615                closeSession(session);
1616            }
1617        }
1618
1619        return count.intValue();
1620    }
1621
1622    public int filterCountByG_A(long groupId, boolean active)
1623        throws SystemException {
1624        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1625            return countByG_A(groupId, active);
1626        }
1627
1628        Session session = null;
1629
1630        try {
1631            session = openSession();
1632
1633            StringBundler query = new StringBundler(3);
1634
1635            query.append(_FILTER_SQL_COUNT_SCFRAMEWORKVERSION_WHERE);
1636
1637            query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1638
1639            query.append(_FINDER_COLUMN_G_A_ACTIVE_2);
1640
1641            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1642                    SCFrameworkVersion.class.getName(),
1643                    _FILTER_COLUMN_FRAMEWORKVERSIONID, _FILTER_COLUMN_USERID,
1644                    groupId);
1645
1646            SQLQuery q = session.createSQLQuery(sql);
1647
1648            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1649
1650            QueryPos qPos = QueryPos.getInstance(q);
1651
1652            qPos.add(groupId);
1653
1654            qPos.add(active);
1655
1656            Long count = (Long)q.uniqueResult();
1657
1658            return count.intValue();
1659        }
1660        catch (Exception e) {
1661            throw processException(e);
1662        }
1663        finally {
1664            closeSession(session);
1665        }
1666    }
1667
1668    public int countAll() throws SystemException {
1669        Object[] finderArgs = new Object[0];
1670
1671        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1672                finderArgs, this);
1673
1674        if (count == null) {
1675            Session session = null;
1676
1677            try {
1678                session = openSession();
1679
1680                Query q = session.createQuery(_SQL_COUNT_SCFRAMEWORKVERSION);
1681
1682                count = (Long)q.uniqueResult();
1683            }
1684            catch (Exception e) {
1685                throw processException(e);
1686            }
1687            finally {
1688                if (count == null) {
1689                    count = Long.valueOf(0);
1690                }
1691
1692                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1693                    count);
1694
1695                closeSession(session);
1696            }
1697        }
1698
1699        return count.intValue();
1700    }
1701
1702    public List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
1703        long pk) throws SystemException {
1704        return getSCProductVersions(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1705    }
1706
1707    public List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
1708        long pk, int start, int end) throws SystemException {
1709        return getSCProductVersions(pk, start, end, null);
1710    }
1711
1712    public static final FinderPath FINDER_PATH_GET_SCPRODUCTVERSIONS = new FinderPath(com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl.ENTITY_CACHE_ENABLED,
1713            SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS,
1714            SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME,
1715            "getSCProductVersions",
1716            new String[] {
1717                Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
1718                "com.liferay.portal.kernel.util.OrderByComparator"
1719            });
1720
1721    public List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
1722        long pk, int start, int end, OrderByComparator orderByComparator)
1723        throws SystemException {
1724        Object[] finderArgs = new Object[] {
1725                new Long(pk), String.valueOf(start), String.valueOf(end),
1726                String.valueOf(orderByComparator)
1727            };
1728
1729        List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> list = (List<com.liferay.portlet.softwarecatalog.model.SCProductVersion>)FinderCacheUtil.getResult(FINDER_PATH_GET_SCPRODUCTVERSIONS,
1730                finderArgs, this);
1731
1732        if (list == null) {
1733            Session session = null;
1734
1735            try {
1736                session = openSession();
1737
1738                String sql = null;
1739
1740                if (orderByComparator != null) {
1741                    sql = _SQL_GETSCPRODUCTVERSIONS.concat(ORDER_BY_CLAUSE)
1742                                                   .concat(orderByComparator.getOrderBy());
1743                }
1744
1745                else {
1746                    sql = _SQL_GETSCPRODUCTVERSIONS.concat(com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl.ORDER_BY_SQL);
1747                }
1748
1749                SQLQuery q = session.createSQLQuery(sql);
1750
1751                q.addEntity("SCProductVersion",
1752                    com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionImpl.class);
1753
1754                QueryPos qPos = QueryPos.getInstance(q);
1755
1756                qPos.add(pk);
1757
1758                list = (List<com.liferay.portlet.softwarecatalog.model.SCProductVersion>)QueryUtil.list(q,
1759                        getDialect(), start, end);
1760            }
1761            catch (Exception e) {
1762                throw processException(e);
1763            }
1764            finally {
1765                if (list == null) {
1766                    list = new ArrayList<com.liferay.portlet.softwarecatalog.model.SCProductVersion>();
1767                }
1768
1769                scProductVersionPersistence.cacheResult(list);
1770
1771                FinderCacheUtil.putResult(FINDER_PATH_GET_SCPRODUCTVERSIONS,
1772                    finderArgs, list);
1773
1774                closeSession(session);
1775            }
1776        }
1777
1778        return list;
1779    }
1780
1781    public static final FinderPath FINDER_PATH_GET_SCPRODUCTVERSIONS_SIZE = new FinderPath(com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl.ENTITY_CACHE_ENABLED,
1782            SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS,
1783            SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME,
1784            "getSCProductVersionsSize", new String[] { Long.class.getName() });
1785
1786    public int getSCProductVersionsSize(long pk) throws SystemException {
1787        Object[] finderArgs = new Object[] { new Long(pk) };
1788
1789        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_GET_SCPRODUCTVERSIONS_SIZE,
1790                finderArgs, this);
1791
1792        if (count == null) {
1793            Session session = null;
1794
1795            try {
1796                session = openSession();
1797
1798                SQLQuery q = session.createSQLQuery(_SQL_GETSCPRODUCTVERSIONSSIZE);
1799
1800                q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1801
1802                QueryPos qPos = QueryPos.getInstance(q);
1803
1804                qPos.add(pk);
1805
1806                count = (Long)q.uniqueResult();
1807            }
1808            catch (Exception e) {
1809                throw processException(e);
1810            }
1811            finally {
1812                if (count == null) {
1813                    count = Long.valueOf(0);
1814                }
1815
1816                FinderCacheUtil.putResult(FINDER_PATH_GET_SCPRODUCTVERSIONS_SIZE,
1817                    finderArgs, count);
1818
1819                closeSession(session);
1820            }
1821        }
1822
1823        return count.intValue();
1824    }
1825
1826    public static final FinderPath FINDER_PATH_CONTAINS_SCPRODUCTVERSION = new FinderPath(com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl.ENTITY_CACHE_ENABLED,
1827            SCFrameworkVersionModelImpl.FINDER_CACHE_ENABLED_SCFRAMEWORKVERSI_SCPRODUCTVERS,
1828            SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME,
1829            "containsSCProductVersion",
1830            new String[] { Long.class.getName(), Long.class.getName() });
1831
1832    public boolean containsSCProductVersion(long pk, long scProductVersionPK)
1833        throws SystemException {
1834        Object[] finderArgs = new Object[] {
1835                new Long(pk),
1836                
1837                new Long(scProductVersionPK)
1838            };
1839
1840        Boolean value = (Boolean)FinderCacheUtil.getResult(FINDER_PATH_CONTAINS_SCPRODUCTVERSION,
1841                finderArgs, this);
1842
1843        if (value == null) {
1844            try {
1845                value = Boolean.valueOf(containsSCProductVersion.contains(pk,
1846                            scProductVersionPK));
1847            }
1848            catch (Exception e) {
1849                throw processException(e);
1850            }
1851            finally {
1852                if (value == null) {
1853                    value = Boolean.FALSE;
1854                }
1855
1856                FinderCacheUtil.putResult(FINDER_PATH_CONTAINS_SCPRODUCTVERSION,
1857                    finderArgs, value);
1858            }
1859        }
1860
1861        return value.booleanValue();
1862    }
1863
1864    public boolean containsSCProductVersions(long pk) throws SystemException {
1865        if (getSCProductVersionsSize(pk) > 0) {
1866            return true;
1867        }
1868        else {
1869            return false;
1870        }
1871    }
1872
1873    public void addSCProductVersion(long pk, long scProductVersionPK)
1874        throws SystemException {
1875        try {
1876            addSCProductVersion.add(pk, scProductVersionPK);
1877        }
1878        catch (Exception e) {
1879            throw processException(e);
1880        }
1881        finally {
1882            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1883        }
1884    }
1885
1886    public void addSCProductVersion(long pk,
1887        com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1888        throws SystemException {
1889        try {
1890            addSCProductVersion.add(pk, scProductVersion.getPrimaryKey());
1891        }
1892        catch (Exception e) {
1893            throw processException(e);
1894        }
1895        finally {
1896            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1897        }
1898    }
1899
1900    public void addSCProductVersions(long pk, long[] scProductVersionPKs)
1901        throws SystemException {
1902        try {
1903            for (long scProductVersionPK : scProductVersionPKs) {
1904                addSCProductVersion.add(pk, scProductVersionPK);
1905            }
1906        }
1907        catch (Exception e) {
1908            throw processException(e);
1909        }
1910        finally {
1911            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1912        }
1913    }
1914
1915    public void addSCProductVersions(long pk,
1916        List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1917        throws SystemException {
1918        try {
1919            for (com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion : scProductVersions) {
1920                addSCProductVersion.add(pk, scProductVersion.getPrimaryKey());
1921            }
1922        }
1923        catch (Exception e) {
1924            throw processException(e);
1925        }
1926        finally {
1927            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1928        }
1929    }
1930
1931    public void clearSCProductVersions(long pk) throws SystemException {
1932        try {
1933            clearSCProductVersions.clear(pk);
1934        }
1935        catch (Exception e) {
1936            throw processException(e);
1937        }
1938        finally {
1939            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1940        }
1941    }
1942
1943    public void removeSCProductVersion(long pk, long scProductVersionPK)
1944        throws SystemException {
1945        try {
1946            removeSCProductVersion.remove(pk, scProductVersionPK);
1947        }
1948        catch (Exception e) {
1949            throw processException(e);
1950        }
1951        finally {
1952            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1953        }
1954    }
1955
1956    public void removeSCProductVersion(long pk,
1957        com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion)
1958        throws SystemException {
1959        try {
1960            removeSCProductVersion.remove(pk, scProductVersion.getPrimaryKey());
1961        }
1962        catch (Exception e) {
1963            throw processException(e);
1964        }
1965        finally {
1966            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1967        }
1968    }
1969
1970    public void removeSCProductVersions(long pk, long[] scProductVersionPKs)
1971        throws SystemException {
1972        try {
1973            for (long scProductVersionPK : scProductVersionPKs) {
1974                removeSCProductVersion.remove(pk, scProductVersionPK);
1975            }
1976        }
1977        catch (Exception e) {
1978            throw processException(e);
1979        }
1980        finally {
1981            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1982        }
1983    }
1984
1985    public void removeSCProductVersions(long pk,
1986        List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
1987        throws SystemException {
1988        try {
1989            for (com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion : scProductVersions) {
1990                removeSCProductVersion.remove(pk,
1991                    scProductVersion.getPrimaryKey());
1992            }
1993        }
1994        catch (Exception e) {
1995            throw processException(e);
1996        }
1997        finally {
1998            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
1999        }
2000    }
2001
2002    public void setSCProductVersions(long pk, long[] scProductVersionPKs)
2003        throws SystemException {
2004        try {
2005            Set<Long> scProductVersionPKSet = SetUtil.fromArray(scProductVersionPKs);
2006
2007            List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions =
2008                getSCProductVersions(pk);
2009
2010            for (com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion : scProductVersions) {
2011                if (!scProductVersionPKSet.contains(
2012                            scProductVersion.getPrimaryKey())) {
2013                    removeSCProductVersion.remove(pk,
2014                        scProductVersion.getPrimaryKey());
2015                }
2016                else {
2017                    scProductVersionPKSet.remove(scProductVersion.getPrimaryKey());
2018                }
2019            }
2020
2021            for (Long scProductVersionPK : scProductVersionPKSet) {
2022                addSCProductVersion.add(pk, scProductVersionPK);
2023            }
2024        }
2025        catch (Exception e) {
2026            throw processException(e);
2027        }
2028        finally {
2029            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
2030        }
2031    }
2032
2033    public void setSCProductVersions(long pk,
2034        List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions)
2035        throws SystemException {
2036        try {
2037            long[] scProductVersionPKs = new long[scProductVersions.size()];
2038
2039            for (int i = 0; i < scProductVersions.size(); i++) {
2040                com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion =
2041                    scProductVersions.get(i);
2042
2043                scProductVersionPKs[i] = scProductVersion.getPrimaryKey();
2044            }
2045
2046            setSCProductVersions(pk, scProductVersionPKs);
2047        }
2048        catch (Exception e) {
2049            throw processException(e);
2050        }
2051        finally {
2052            FinderCacheUtil.clearCache(SCFrameworkVersionModelImpl.MAPPING_TABLE_SCFRAMEWORKVERSI_SCPRODUCTVERS_NAME);
2053        }
2054    }
2055
2056    public void afterPropertiesSet() {
2057        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2058                    com.liferay.portal.util.PropsUtil.get(
2059                        "value.object.listener.com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion")));
2060
2061        if (listenerClassNames.length > 0) {
2062            try {
2063                List<ModelListener<SCFrameworkVersion>> listenersList = new ArrayList<ModelListener<SCFrameworkVersion>>();
2064
2065                for (String listenerClassName : listenerClassNames) {
2066                    listenersList.add((ModelListener<SCFrameworkVersion>)InstanceFactory.newInstance(
2067                            listenerClassName));
2068                }
2069
2070                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2071            }
2072            catch (Exception e) {
2073                _log.error(e);
2074            }
2075        }
2076
2077        containsSCProductVersion = new ContainsSCProductVersion(this);
2078
2079        addSCProductVersion = new AddSCProductVersion(this);
2080        clearSCProductVersions = new ClearSCProductVersions(this);
2081        removeSCProductVersion = new RemoveSCProductVersion(this);
2082    }
2083
2084    @BeanReference(type = SCLicensePersistence.class)
2085    protected SCLicensePersistence scLicensePersistence;
2086    @BeanReference(type = SCFrameworkVersionPersistence.class)
2087    protected SCFrameworkVersionPersistence scFrameworkVersionPersistence;
2088    @BeanReference(type = SCProductEntryPersistence.class)
2089    protected SCProductEntryPersistence scProductEntryPersistence;
2090    @BeanReference(type = SCProductScreenshotPersistence.class)
2091    protected SCProductScreenshotPersistence scProductScreenshotPersistence;
2092    @BeanReference(type = SCProductVersionPersistence.class)
2093    protected SCProductVersionPersistence scProductVersionPersistence;
2094    @BeanReference(type = ResourcePersistence.class)
2095    protected ResourcePersistence resourcePersistence;
2096    @BeanReference(type = UserPersistence.class)
2097    protected UserPersistence userPersistence;
2098    protected ContainsSCProductVersion containsSCProductVersion;
2099    protected AddSCProductVersion addSCProductVersion;
2100    protected ClearSCProductVersions clearSCProductVersions;
2101    protected RemoveSCProductVersion removeSCProductVersion;
2102
2103    protected class ContainsSCProductVersion {
2104        protected ContainsSCProductVersion(
2105            SCFrameworkVersionPersistenceImpl persistenceImpl) {
2106            super();
2107
2108            _mappingSqlQuery = MappingSqlQueryFactoryUtil.getMappingSqlQuery(getDataSource(),
2109                    _SQL_CONTAINSSCPRODUCTVERSION,
2110                    new int[] { Types.BIGINT, Types.BIGINT }, RowMapper.COUNT);
2111        }
2112
2113        protected boolean contains(long frameworkVersionId,
2114            long productVersionId) {
2115            List<Integer> results = _mappingSqlQuery.execute(new Object[] {
2116                        new Long(frameworkVersionId), new Long(productVersionId)
2117                    });
2118
2119            if (results.size() > 0) {
2120                Integer count = results.get(0);
2121
2122                if (count.intValue() > 0) {
2123                    return true;
2124                }
2125            }
2126
2127            return false;
2128        }
2129
2130        private MappingSqlQuery<Integer> _mappingSqlQuery;
2131    }
2132
2133    protected class AddSCProductVersion {
2134        protected AddSCProductVersion(
2135            SCFrameworkVersionPersistenceImpl persistenceImpl) {
2136            _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2137                    "INSERT INTO SCFrameworkVersi_SCProductVers (frameworkVersionId, productVersionId) VALUES (?, ?)",
2138                    new int[] { Types.BIGINT, Types.BIGINT });
2139            _persistenceImpl = persistenceImpl;
2140        }
2141
2142        protected void add(long frameworkVersionId, long productVersionId)
2143            throws SystemException {
2144            if (!_persistenceImpl.containsSCProductVersion.contains(
2145                        frameworkVersionId, productVersionId)) {
2146                ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion>[] scProductVersionListeners =
2147                    scProductVersionPersistence.getListeners();
2148
2149                for (ModelListener<SCFrameworkVersion> listener : listeners) {
2150                    listener.onBeforeAddAssociation(frameworkVersionId,
2151                        com.liferay.portlet.softwarecatalog.model.SCProductVersion.class.getName(),
2152                        productVersionId);
2153                }
2154
2155                for (ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion> listener : scProductVersionListeners) {
2156                    listener.onBeforeAddAssociation(productVersionId,
2157                        SCFrameworkVersion.class.getName(), frameworkVersionId);
2158                }
2159
2160                _sqlUpdate.update(new Object[] {
2161                        new Long(frameworkVersionId), new Long(productVersionId)
2162                    });
2163
2164                for (ModelListener<SCFrameworkVersion> listener : listeners) {
2165                    listener.onAfterAddAssociation(frameworkVersionId,
2166                        com.liferay.portlet.softwarecatalog.model.SCProductVersion.class.getName(),
2167                        productVersionId);
2168                }
2169
2170                for (ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion> listener : scProductVersionListeners) {
2171                    listener.onAfterAddAssociation(productVersionId,
2172                        SCFrameworkVersion.class.getName(), frameworkVersionId);
2173                }
2174            }
2175        }
2176
2177        private SqlUpdate _sqlUpdate;
2178        private SCFrameworkVersionPersistenceImpl _persistenceImpl;
2179    }
2180
2181    protected class ClearSCProductVersions {
2182        protected ClearSCProductVersions(
2183            SCFrameworkVersionPersistenceImpl persistenceImpl) {
2184            _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2185                    "DELETE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ?",
2186                    new int[] { Types.BIGINT });
2187        }
2188
2189        protected void clear(long frameworkVersionId) throws SystemException {
2190            ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion>[] scProductVersionListeners =
2191                scProductVersionPersistence.getListeners();
2192
2193            List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions =
2194                null;
2195
2196            if ((listeners.length > 0) ||
2197                    (scProductVersionListeners.length > 0)) {
2198                scProductVersions = getSCProductVersions(frameworkVersionId);
2199
2200                for (com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion : scProductVersions) {
2201                    for (ModelListener<SCFrameworkVersion> listener : listeners) {
2202                        listener.onBeforeRemoveAssociation(frameworkVersionId,
2203                            com.liferay.portlet.softwarecatalog.model.SCProductVersion.class.getName(),
2204                            scProductVersion.getPrimaryKey());
2205                    }
2206
2207                    for (ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion> listener : scProductVersionListeners) {
2208                        listener.onBeforeRemoveAssociation(scProductVersion.getPrimaryKey(),
2209                            SCFrameworkVersion.class.getName(),
2210                            frameworkVersionId);
2211                    }
2212                }
2213            }
2214
2215            _sqlUpdate.update(new Object[] { new Long(frameworkVersionId) });
2216
2217            if ((listeners.length > 0) ||
2218                    (scProductVersionListeners.length > 0)) {
2219                for (com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion : scProductVersions) {
2220                    for (ModelListener<SCFrameworkVersion> listener : listeners) {
2221                        listener.onAfterRemoveAssociation(frameworkVersionId,
2222                            com.liferay.portlet.softwarecatalog.model.SCProductVersion.class.getName(),
2223                            scProductVersion.getPrimaryKey());
2224                    }
2225
2226                    for (ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion> listener : scProductVersionListeners) {
2227                        listener.onAfterRemoveAssociation(scProductVersion.getPrimaryKey(),
2228                            SCFrameworkVersion.class.getName(),
2229                            frameworkVersionId);
2230                    }
2231                }
2232            }
2233        }
2234
2235        private SqlUpdate _sqlUpdate;
2236    }
2237
2238    protected class RemoveSCProductVersion {
2239        protected RemoveSCProductVersion(
2240            SCFrameworkVersionPersistenceImpl persistenceImpl) {
2241            _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2242                    "DELETE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ? AND productVersionId = ?",
2243                    new int[] { Types.BIGINT, Types.BIGINT });
2244            _persistenceImpl = persistenceImpl;
2245        }
2246
2247        protected void remove(long frameworkVersionId, long productVersionId)
2248            throws SystemException {
2249            if (_persistenceImpl.containsSCProductVersion.contains(
2250                        frameworkVersionId, productVersionId)) {
2251                ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion>[] scProductVersionListeners =
2252                    scProductVersionPersistence.getListeners();
2253
2254                for (ModelListener<SCFrameworkVersion> listener : listeners) {
2255                    listener.onBeforeRemoveAssociation(frameworkVersionId,
2256                        com.liferay.portlet.softwarecatalog.model.SCProductVersion.class.getName(),
2257                        productVersionId);
2258                }
2259
2260                for (ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion> listener : scProductVersionListeners) {
2261                    listener.onBeforeRemoveAssociation(productVersionId,
2262                        SCFrameworkVersion.class.getName(), frameworkVersionId);
2263                }
2264
2265                _sqlUpdate.update(new Object[] {
2266                        new Long(frameworkVersionId), new Long(productVersionId)
2267                    });
2268
2269                for (ModelListener<SCFrameworkVersion> listener : listeners) {
2270                    listener.onAfterRemoveAssociation(frameworkVersionId,
2271                        com.liferay.portlet.softwarecatalog.model.SCProductVersion.class.getName(),
2272                        productVersionId);
2273                }
2274
2275                for (ModelListener<com.liferay.portlet.softwarecatalog.model.SCProductVersion> listener : scProductVersionListeners) {
2276                    listener.onAfterRemoveAssociation(productVersionId,
2277                        SCFrameworkVersion.class.getName(), frameworkVersionId);
2278                }
2279            }
2280        }
2281
2282        private SqlUpdate _sqlUpdate;
2283        private SCFrameworkVersionPersistenceImpl _persistenceImpl;
2284    }
2285
2286    private static final String _SQL_SELECT_SCFRAMEWORKVERSION = "SELECT scFrameworkVersion FROM SCFrameworkVersion scFrameworkVersion";
2287    private static final String _SQL_SELECT_SCFRAMEWORKVERSION_WHERE = "SELECT scFrameworkVersion FROM SCFrameworkVersion scFrameworkVersion WHERE ";
2288    private static final String _SQL_COUNT_SCFRAMEWORKVERSION = "SELECT COUNT(scFrameworkVersion) FROM SCFrameworkVersion scFrameworkVersion";
2289    private static final String _SQL_COUNT_SCFRAMEWORKVERSION_WHERE = "SELECT COUNT(scFrameworkVersion) FROM SCFrameworkVersion scFrameworkVersion WHERE ";
2290    private static final String _SQL_GETSCPRODUCTVERSIONS = "SELECT {SCProductVersion.*} FROM SCProductVersion INNER JOIN SCFrameworkVersi_SCProductVers ON (SCFrameworkVersi_SCProductVers.productVersionId = SCProductVersion.productVersionId) WHERE (SCFrameworkVersi_SCProductVers.frameworkVersionId = ?)";
2291    private static final String _SQL_GETSCPRODUCTVERSIONSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ?";
2292    private static final String _SQL_CONTAINSSCPRODUCTVERSION = "SELECT COUNT(*) AS COUNT_VALUE FROM SCFrameworkVersi_SCProductVers WHERE frameworkVersionId = ? AND productVersionId = ?";
2293    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "scFrameworkVersion.groupId = ?";
2294    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "scFrameworkVersion.companyId = ?";
2295    private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "scFrameworkVersion.groupId = ? AND ";
2296    private static final String _FINDER_COLUMN_G_A_ACTIVE_2 = "scFrameworkVersion.active = ?";
2297    private static final String _FILTER_SQL_SELECT_SCFRAMEWORKVERSION_WHERE = "SELECT DISTINCT {scFrameworkVersion.*} FROM SCFrameworkVersion scFrameworkVersion WHERE ";
2298    private static final String _FILTER_SQL_COUNT_SCFRAMEWORKVERSION_WHERE = "SELECT COUNT(DISTINCT scFrameworkVersion.frameworkVersionId) AS COUNT_VALUE FROM SCFrameworkVersion scFrameworkVersion WHERE ";
2299    private static final String _FILTER_COLUMN_FRAMEWORKVERSIONID = "scFrameworkVersion.frameworkVersionId";
2300    private static final String _FILTER_COLUMN_USERID = "scFrameworkVersion.userId";
2301    private static final String _FILTER_ENTITY_ALIAS = "scFrameworkVersion";
2302    private static final String _ORDER_BY_ENTITY_ALIAS = "scFrameworkVersion.";
2303    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No SCFrameworkVersion exists with the primary key ";
2304    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No SCFrameworkVersion exists with the key {";
2305    private static Log _log = LogFactoryUtil.getLog(SCFrameworkVersionPersistenceImpl.class);
2306}