1
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
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
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
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}