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