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