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