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