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