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