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