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