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