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