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