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