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