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