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