001
014
015 package com.liferay.portal.service.persistence.impl;
016
017 import aQute.bnd.annotation.ProviderType;
018
019 import com.liferay.portal.NoSuchResourceBlockPermissionException;
020 import com.liferay.portal.kernel.dao.orm.EntityCache;
021 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
022 import com.liferay.portal.kernel.dao.orm.FinderCache;
023 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
024 import com.liferay.portal.kernel.dao.orm.FinderPath;
025 import com.liferay.portal.kernel.dao.orm.Query;
026 import com.liferay.portal.kernel.dao.orm.QueryPos;
027 import com.liferay.portal.kernel.dao.orm.QueryUtil;
028 import com.liferay.portal.kernel.dao.orm.Session;
029 import com.liferay.portal.kernel.log.Log;
030 import com.liferay.portal.kernel.log.LogFactoryUtil;
031 import com.liferay.portal.kernel.util.OrderByComparator;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.model.CacheModel;
035 import com.liferay.portal.model.MVCCModel;
036 import com.liferay.portal.model.ResourceBlockPermission;
037 import com.liferay.portal.model.impl.ResourceBlockPermissionImpl;
038 import com.liferay.portal.model.impl.ResourceBlockPermissionModelImpl;
039 import com.liferay.portal.service.persistence.ResourceBlockPermissionPersistence;
040
041 import java.io.Serializable;
042
043 import java.util.Collections;
044 import java.util.HashMap;
045 import java.util.HashSet;
046 import java.util.Iterator;
047 import java.util.List;
048 import java.util.Map;
049 import java.util.Set;
050
051
063 @ProviderType
064 public class ResourceBlockPermissionPersistenceImpl extends BasePersistenceImpl<ResourceBlockPermission>
065 implements ResourceBlockPermissionPersistence {
066
071 public static final String FINDER_CLASS_NAME_ENTITY = ResourceBlockPermissionImpl.class.getName();
072 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
073 ".List1";
074 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
075 ".List2";
076 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
077 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
078 ResourceBlockPermissionImpl.class,
079 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
080 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
081 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
082 ResourceBlockPermissionImpl.class,
083 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
084 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
085 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED, Long.class,
086 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
087 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_RESOURCEBLOCKID =
088 new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
089 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
090 ResourceBlockPermissionImpl.class,
091 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByResourceBlockId",
092 new String[] {
093 Long.class.getName(),
094
095 Integer.class.getName(), Integer.class.getName(),
096 OrderByComparator.class.getName()
097 });
098 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_RESOURCEBLOCKID =
099 new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
100 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
101 ResourceBlockPermissionImpl.class,
102 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByResourceBlockId",
103 new String[] { Long.class.getName() },
104 ResourceBlockPermissionModelImpl.RESOURCEBLOCKID_COLUMN_BITMASK);
105 public static final FinderPath FINDER_PATH_COUNT_BY_RESOURCEBLOCKID = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
106 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED, Long.class,
107 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
108 "countByResourceBlockId", new String[] { Long.class.getName() });
109
110
116 @Override
117 public List<ResourceBlockPermission> findByResourceBlockId(
118 long resourceBlockId) {
119 return findByResourceBlockId(resourceBlockId, QueryUtil.ALL_POS,
120 QueryUtil.ALL_POS, null);
121 }
122
123
135 @Override
136 public List<ResourceBlockPermission> findByResourceBlockId(
137 long resourceBlockId, int start, int end) {
138 return findByResourceBlockId(resourceBlockId, start, end, null);
139 }
140
141
154 @Override
155 public List<ResourceBlockPermission> findByResourceBlockId(
156 long resourceBlockId, int start, int end,
157 OrderByComparator<ResourceBlockPermission> orderByComparator) {
158 return findByResourceBlockId(resourceBlockId, start, end,
159 orderByComparator, true);
160 }
161
162
176 @Override
177 public List<ResourceBlockPermission> findByResourceBlockId(
178 long resourceBlockId, int start, int end,
179 OrderByComparator<ResourceBlockPermission> orderByComparator,
180 boolean retrieveFromCache) {
181 boolean pagination = true;
182 FinderPath finderPath = null;
183 Object[] finderArgs = null;
184
185 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
186 (orderByComparator == null)) {
187 pagination = false;
188 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_RESOURCEBLOCKID;
189 finderArgs = new Object[] { resourceBlockId };
190 }
191 else {
192 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_RESOURCEBLOCKID;
193 finderArgs = new Object[] {
194 resourceBlockId,
195
196 start, end, orderByComparator
197 };
198 }
199
200 List<ResourceBlockPermission> list = null;
201
202 if (retrieveFromCache) {
203 list = (List<ResourceBlockPermission>)finderCache.getResult(finderPath,
204 finderArgs, this);
205
206 if ((list != null) && !list.isEmpty()) {
207 for (ResourceBlockPermission resourceBlockPermission : list) {
208 if ((resourceBlockId != resourceBlockPermission.getResourceBlockId())) {
209 list = null;
210
211 break;
212 }
213 }
214 }
215 }
216
217 if (list == null) {
218 StringBundler query = null;
219
220 if (orderByComparator != null) {
221 query = new StringBundler(3 +
222 (orderByComparator.getOrderByFields().length * 3));
223 }
224 else {
225 query = new StringBundler(3);
226 }
227
228 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE);
229
230 query.append(_FINDER_COLUMN_RESOURCEBLOCKID_RESOURCEBLOCKID_2);
231
232 if (orderByComparator != null) {
233 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
234 orderByComparator);
235 }
236 else
237 if (pagination) {
238 query.append(ResourceBlockPermissionModelImpl.ORDER_BY_JPQL);
239 }
240
241 String sql = query.toString();
242
243 Session session = null;
244
245 try {
246 session = openSession();
247
248 Query q = session.createQuery(sql);
249
250 QueryPos qPos = QueryPos.getInstance(q);
251
252 qPos.add(resourceBlockId);
253
254 if (!pagination) {
255 list = (List<ResourceBlockPermission>)QueryUtil.list(q,
256 getDialect(), start, end, false);
257
258 Collections.sort(list);
259
260 list = Collections.unmodifiableList(list);
261 }
262 else {
263 list = (List<ResourceBlockPermission>)QueryUtil.list(q,
264 getDialect(), start, end);
265 }
266
267 cacheResult(list);
268
269 finderCache.putResult(finderPath, finderArgs, list);
270 }
271 catch (Exception e) {
272 finderCache.removeResult(finderPath, finderArgs);
273
274 throw processException(e);
275 }
276 finally {
277 closeSession(session);
278 }
279 }
280
281 return list;
282 }
283
284
292 @Override
293 public ResourceBlockPermission findByResourceBlockId_First(
294 long resourceBlockId,
295 OrderByComparator<ResourceBlockPermission> orderByComparator)
296 throws NoSuchResourceBlockPermissionException {
297 ResourceBlockPermission resourceBlockPermission = fetchByResourceBlockId_First(resourceBlockId,
298 orderByComparator);
299
300 if (resourceBlockPermission != null) {
301 return resourceBlockPermission;
302 }
303
304 StringBundler msg = new StringBundler(4);
305
306 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
307
308 msg.append("resourceBlockId=");
309 msg.append(resourceBlockId);
310
311 msg.append(StringPool.CLOSE_CURLY_BRACE);
312
313 throw new NoSuchResourceBlockPermissionException(msg.toString());
314 }
315
316
323 @Override
324 public ResourceBlockPermission fetchByResourceBlockId_First(
325 long resourceBlockId,
326 OrderByComparator<ResourceBlockPermission> orderByComparator) {
327 List<ResourceBlockPermission> list = findByResourceBlockId(resourceBlockId,
328 0, 1, orderByComparator);
329
330 if (!list.isEmpty()) {
331 return list.get(0);
332 }
333
334 return null;
335 }
336
337
345 @Override
346 public ResourceBlockPermission findByResourceBlockId_Last(
347 long resourceBlockId,
348 OrderByComparator<ResourceBlockPermission> orderByComparator)
349 throws NoSuchResourceBlockPermissionException {
350 ResourceBlockPermission resourceBlockPermission = fetchByResourceBlockId_Last(resourceBlockId,
351 orderByComparator);
352
353 if (resourceBlockPermission != null) {
354 return resourceBlockPermission;
355 }
356
357 StringBundler msg = new StringBundler(4);
358
359 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
360
361 msg.append("resourceBlockId=");
362 msg.append(resourceBlockId);
363
364 msg.append(StringPool.CLOSE_CURLY_BRACE);
365
366 throw new NoSuchResourceBlockPermissionException(msg.toString());
367 }
368
369
376 @Override
377 public ResourceBlockPermission fetchByResourceBlockId_Last(
378 long resourceBlockId,
379 OrderByComparator<ResourceBlockPermission> orderByComparator) {
380 int count = countByResourceBlockId(resourceBlockId);
381
382 if (count == 0) {
383 return null;
384 }
385
386 List<ResourceBlockPermission> list = findByResourceBlockId(resourceBlockId,
387 count - 1, count, orderByComparator);
388
389 if (!list.isEmpty()) {
390 return list.get(0);
391 }
392
393 return null;
394 }
395
396
405 @Override
406 public ResourceBlockPermission[] findByResourceBlockId_PrevAndNext(
407 long resourceBlockPermissionId, long resourceBlockId,
408 OrderByComparator<ResourceBlockPermission> orderByComparator)
409 throws NoSuchResourceBlockPermissionException {
410 ResourceBlockPermission resourceBlockPermission = findByPrimaryKey(resourceBlockPermissionId);
411
412 Session session = null;
413
414 try {
415 session = openSession();
416
417 ResourceBlockPermission[] array = new ResourceBlockPermissionImpl[3];
418
419 array[0] = getByResourceBlockId_PrevAndNext(session,
420 resourceBlockPermission, resourceBlockId,
421 orderByComparator, true);
422
423 array[1] = resourceBlockPermission;
424
425 array[2] = getByResourceBlockId_PrevAndNext(session,
426 resourceBlockPermission, resourceBlockId,
427 orderByComparator, false);
428
429 return array;
430 }
431 catch (Exception e) {
432 throw processException(e);
433 }
434 finally {
435 closeSession(session);
436 }
437 }
438
439 protected ResourceBlockPermission getByResourceBlockId_PrevAndNext(
440 Session session, ResourceBlockPermission resourceBlockPermission,
441 long resourceBlockId,
442 OrderByComparator<ResourceBlockPermission> orderByComparator,
443 boolean previous) {
444 StringBundler query = null;
445
446 if (orderByComparator != null) {
447 query = new StringBundler(6 +
448 (orderByComparator.getOrderByFields().length * 6));
449 }
450 else {
451 query = new StringBundler(3);
452 }
453
454 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE);
455
456 query.append(_FINDER_COLUMN_RESOURCEBLOCKID_RESOURCEBLOCKID_2);
457
458 if (orderByComparator != null) {
459 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
460
461 if (orderByConditionFields.length > 0) {
462 query.append(WHERE_AND);
463 }
464
465 for (int i = 0; i < orderByConditionFields.length; i++) {
466 query.append(_ORDER_BY_ENTITY_ALIAS);
467 query.append(orderByConditionFields[i]);
468
469 if ((i + 1) < orderByConditionFields.length) {
470 if (orderByComparator.isAscending() ^ previous) {
471 query.append(WHERE_GREATER_THAN_HAS_NEXT);
472 }
473 else {
474 query.append(WHERE_LESSER_THAN_HAS_NEXT);
475 }
476 }
477 else {
478 if (orderByComparator.isAscending() ^ previous) {
479 query.append(WHERE_GREATER_THAN);
480 }
481 else {
482 query.append(WHERE_LESSER_THAN);
483 }
484 }
485 }
486
487 query.append(ORDER_BY_CLAUSE);
488
489 String[] orderByFields = orderByComparator.getOrderByFields();
490
491 for (int i = 0; i < orderByFields.length; i++) {
492 query.append(_ORDER_BY_ENTITY_ALIAS);
493 query.append(orderByFields[i]);
494
495 if ((i + 1) < orderByFields.length) {
496 if (orderByComparator.isAscending() ^ previous) {
497 query.append(ORDER_BY_ASC_HAS_NEXT);
498 }
499 else {
500 query.append(ORDER_BY_DESC_HAS_NEXT);
501 }
502 }
503 else {
504 if (orderByComparator.isAscending() ^ previous) {
505 query.append(ORDER_BY_ASC);
506 }
507 else {
508 query.append(ORDER_BY_DESC);
509 }
510 }
511 }
512 }
513 else {
514 query.append(ResourceBlockPermissionModelImpl.ORDER_BY_JPQL);
515 }
516
517 String sql = query.toString();
518
519 Query q = session.createQuery(sql);
520
521 q.setFirstResult(0);
522 q.setMaxResults(2);
523
524 QueryPos qPos = QueryPos.getInstance(q);
525
526 qPos.add(resourceBlockId);
527
528 if (orderByComparator != null) {
529 Object[] values = orderByComparator.getOrderByConditionValues(resourceBlockPermission);
530
531 for (Object value : values) {
532 qPos.add(value);
533 }
534 }
535
536 List<ResourceBlockPermission> list = q.list();
537
538 if (list.size() == 2) {
539 return list.get(1);
540 }
541 else {
542 return null;
543 }
544 }
545
546
551 @Override
552 public void removeByResourceBlockId(long resourceBlockId) {
553 for (ResourceBlockPermission resourceBlockPermission : findByResourceBlockId(
554 resourceBlockId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
555 remove(resourceBlockPermission);
556 }
557 }
558
559
565 @Override
566 public int countByResourceBlockId(long resourceBlockId) {
567 FinderPath finderPath = FINDER_PATH_COUNT_BY_RESOURCEBLOCKID;
568
569 Object[] finderArgs = new Object[] { resourceBlockId };
570
571 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
572
573 if (count == null) {
574 StringBundler query = new StringBundler(2);
575
576 query.append(_SQL_COUNT_RESOURCEBLOCKPERMISSION_WHERE);
577
578 query.append(_FINDER_COLUMN_RESOURCEBLOCKID_RESOURCEBLOCKID_2);
579
580 String sql = query.toString();
581
582 Session session = null;
583
584 try {
585 session = openSession();
586
587 Query q = session.createQuery(sql);
588
589 QueryPos qPos = QueryPos.getInstance(q);
590
591 qPos.add(resourceBlockId);
592
593 count = (Long)q.uniqueResult();
594
595 finderCache.putResult(finderPath, finderArgs, count);
596 }
597 catch (Exception e) {
598 finderCache.removeResult(finderPath, finderArgs);
599
600 throw processException(e);
601 }
602 finally {
603 closeSession(session);
604 }
605 }
606
607 return count.intValue();
608 }
609
610 private static final String _FINDER_COLUMN_RESOURCEBLOCKID_RESOURCEBLOCKID_2 =
611 "resourceBlockPermission.resourceBlockId = ?";
612 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_ROLEID = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
613 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
614 ResourceBlockPermissionImpl.class,
615 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByRoleId",
616 new String[] {
617 Long.class.getName(),
618
619 Integer.class.getName(), Integer.class.getName(),
620 OrderByComparator.class.getName()
621 });
622 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROLEID =
623 new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
624 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
625 ResourceBlockPermissionImpl.class,
626 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByRoleId",
627 new String[] { Long.class.getName() },
628 ResourceBlockPermissionModelImpl.ROLEID_COLUMN_BITMASK);
629 public static final FinderPath FINDER_PATH_COUNT_BY_ROLEID = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
630 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED, Long.class,
631 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByRoleId",
632 new String[] { Long.class.getName() });
633
634
640 @Override
641 public List<ResourceBlockPermission> findByRoleId(long roleId) {
642 return findByRoleId(roleId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
643 }
644
645
657 @Override
658 public List<ResourceBlockPermission> findByRoleId(long roleId, int start,
659 int end) {
660 return findByRoleId(roleId, start, end, null);
661 }
662
663
676 @Override
677 public List<ResourceBlockPermission> findByRoleId(long roleId, int start,
678 int end, OrderByComparator<ResourceBlockPermission> orderByComparator) {
679 return findByRoleId(roleId, start, end, orderByComparator, true);
680 }
681
682
696 @Override
697 public List<ResourceBlockPermission> findByRoleId(long roleId, int start,
698 int end, OrderByComparator<ResourceBlockPermission> orderByComparator,
699 boolean retrieveFromCache) {
700 boolean pagination = true;
701 FinderPath finderPath = null;
702 Object[] finderArgs = null;
703
704 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
705 (orderByComparator == null)) {
706 pagination = false;
707 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROLEID;
708 finderArgs = new Object[] { roleId };
709 }
710 else {
711 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_ROLEID;
712 finderArgs = new Object[] { roleId, start, end, orderByComparator };
713 }
714
715 List<ResourceBlockPermission> list = null;
716
717 if (retrieveFromCache) {
718 list = (List<ResourceBlockPermission>)finderCache.getResult(finderPath,
719 finderArgs, this);
720
721 if ((list != null) && !list.isEmpty()) {
722 for (ResourceBlockPermission resourceBlockPermission : list) {
723 if ((roleId != resourceBlockPermission.getRoleId())) {
724 list = null;
725
726 break;
727 }
728 }
729 }
730 }
731
732 if (list == null) {
733 StringBundler query = null;
734
735 if (orderByComparator != null) {
736 query = new StringBundler(3 +
737 (orderByComparator.getOrderByFields().length * 3));
738 }
739 else {
740 query = new StringBundler(3);
741 }
742
743 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE);
744
745 query.append(_FINDER_COLUMN_ROLEID_ROLEID_2);
746
747 if (orderByComparator != null) {
748 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
749 orderByComparator);
750 }
751 else
752 if (pagination) {
753 query.append(ResourceBlockPermissionModelImpl.ORDER_BY_JPQL);
754 }
755
756 String sql = query.toString();
757
758 Session session = null;
759
760 try {
761 session = openSession();
762
763 Query q = session.createQuery(sql);
764
765 QueryPos qPos = QueryPos.getInstance(q);
766
767 qPos.add(roleId);
768
769 if (!pagination) {
770 list = (List<ResourceBlockPermission>)QueryUtil.list(q,
771 getDialect(), start, end, false);
772
773 Collections.sort(list);
774
775 list = Collections.unmodifiableList(list);
776 }
777 else {
778 list = (List<ResourceBlockPermission>)QueryUtil.list(q,
779 getDialect(), start, end);
780 }
781
782 cacheResult(list);
783
784 finderCache.putResult(finderPath, finderArgs, list);
785 }
786 catch (Exception e) {
787 finderCache.removeResult(finderPath, finderArgs);
788
789 throw processException(e);
790 }
791 finally {
792 closeSession(session);
793 }
794 }
795
796 return list;
797 }
798
799
807 @Override
808 public ResourceBlockPermission findByRoleId_First(long roleId,
809 OrderByComparator<ResourceBlockPermission> orderByComparator)
810 throws NoSuchResourceBlockPermissionException {
811 ResourceBlockPermission resourceBlockPermission = fetchByRoleId_First(roleId,
812 orderByComparator);
813
814 if (resourceBlockPermission != null) {
815 return resourceBlockPermission;
816 }
817
818 StringBundler msg = new StringBundler(4);
819
820 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
821
822 msg.append("roleId=");
823 msg.append(roleId);
824
825 msg.append(StringPool.CLOSE_CURLY_BRACE);
826
827 throw new NoSuchResourceBlockPermissionException(msg.toString());
828 }
829
830
837 @Override
838 public ResourceBlockPermission fetchByRoleId_First(long roleId,
839 OrderByComparator<ResourceBlockPermission> orderByComparator) {
840 List<ResourceBlockPermission> list = findByRoleId(roleId, 0, 1,
841 orderByComparator);
842
843 if (!list.isEmpty()) {
844 return list.get(0);
845 }
846
847 return null;
848 }
849
850
858 @Override
859 public ResourceBlockPermission findByRoleId_Last(long roleId,
860 OrderByComparator<ResourceBlockPermission> orderByComparator)
861 throws NoSuchResourceBlockPermissionException {
862 ResourceBlockPermission resourceBlockPermission = fetchByRoleId_Last(roleId,
863 orderByComparator);
864
865 if (resourceBlockPermission != null) {
866 return resourceBlockPermission;
867 }
868
869 StringBundler msg = new StringBundler(4);
870
871 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
872
873 msg.append("roleId=");
874 msg.append(roleId);
875
876 msg.append(StringPool.CLOSE_CURLY_BRACE);
877
878 throw new NoSuchResourceBlockPermissionException(msg.toString());
879 }
880
881
888 @Override
889 public ResourceBlockPermission fetchByRoleId_Last(long roleId,
890 OrderByComparator<ResourceBlockPermission> orderByComparator) {
891 int count = countByRoleId(roleId);
892
893 if (count == 0) {
894 return null;
895 }
896
897 List<ResourceBlockPermission> list = findByRoleId(roleId, count - 1,
898 count, orderByComparator);
899
900 if (!list.isEmpty()) {
901 return list.get(0);
902 }
903
904 return null;
905 }
906
907
916 @Override
917 public ResourceBlockPermission[] findByRoleId_PrevAndNext(
918 long resourceBlockPermissionId, long roleId,
919 OrderByComparator<ResourceBlockPermission> orderByComparator)
920 throws NoSuchResourceBlockPermissionException {
921 ResourceBlockPermission resourceBlockPermission = findByPrimaryKey(resourceBlockPermissionId);
922
923 Session session = null;
924
925 try {
926 session = openSession();
927
928 ResourceBlockPermission[] array = new ResourceBlockPermissionImpl[3];
929
930 array[0] = getByRoleId_PrevAndNext(session,
931 resourceBlockPermission, roleId, orderByComparator, true);
932
933 array[1] = resourceBlockPermission;
934
935 array[2] = getByRoleId_PrevAndNext(session,
936 resourceBlockPermission, roleId, orderByComparator, false);
937
938 return array;
939 }
940 catch (Exception e) {
941 throw processException(e);
942 }
943 finally {
944 closeSession(session);
945 }
946 }
947
948 protected ResourceBlockPermission getByRoleId_PrevAndNext(Session session,
949 ResourceBlockPermission resourceBlockPermission, long roleId,
950 OrderByComparator<ResourceBlockPermission> orderByComparator,
951 boolean previous) {
952 StringBundler query = null;
953
954 if (orderByComparator != null) {
955 query = new StringBundler(6 +
956 (orderByComparator.getOrderByFields().length * 6));
957 }
958 else {
959 query = new StringBundler(3);
960 }
961
962 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE);
963
964 query.append(_FINDER_COLUMN_ROLEID_ROLEID_2);
965
966 if (orderByComparator != null) {
967 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
968
969 if (orderByConditionFields.length > 0) {
970 query.append(WHERE_AND);
971 }
972
973 for (int i = 0; i < orderByConditionFields.length; i++) {
974 query.append(_ORDER_BY_ENTITY_ALIAS);
975 query.append(orderByConditionFields[i]);
976
977 if ((i + 1) < orderByConditionFields.length) {
978 if (orderByComparator.isAscending() ^ previous) {
979 query.append(WHERE_GREATER_THAN_HAS_NEXT);
980 }
981 else {
982 query.append(WHERE_LESSER_THAN_HAS_NEXT);
983 }
984 }
985 else {
986 if (orderByComparator.isAscending() ^ previous) {
987 query.append(WHERE_GREATER_THAN);
988 }
989 else {
990 query.append(WHERE_LESSER_THAN);
991 }
992 }
993 }
994
995 query.append(ORDER_BY_CLAUSE);
996
997 String[] orderByFields = orderByComparator.getOrderByFields();
998
999 for (int i = 0; i < orderByFields.length; i++) {
1000 query.append(_ORDER_BY_ENTITY_ALIAS);
1001 query.append(orderByFields[i]);
1002
1003 if ((i + 1) < orderByFields.length) {
1004 if (orderByComparator.isAscending() ^ previous) {
1005 query.append(ORDER_BY_ASC_HAS_NEXT);
1006 }
1007 else {
1008 query.append(ORDER_BY_DESC_HAS_NEXT);
1009 }
1010 }
1011 else {
1012 if (orderByComparator.isAscending() ^ previous) {
1013 query.append(ORDER_BY_ASC);
1014 }
1015 else {
1016 query.append(ORDER_BY_DESC);
1017 }
1018 }
1019 }
1020 }
1021 else {
1022 query.append(ResourceBlockPermissionModelImpl.ORDER_BY_JPQL);
1023 }
1024
1025 String sql = query.toString();
1026
1027 Query q = session.createQuery(sql);
1028
1029 q.setFirstResult(0);
1030 q.setMaxResults(2);
1031
1032 QueryPos qPos = QueryPos.getInstance(q);
1033
1034 qPos.add(roleId);
1035
1036 if (orderByComparator != null) {
1037 Object[] values = orderByComparator.getOrderByConditionValues(resourceBlockPermission);
1038
1039 for (Object value : values) {
1040 qPos.add(value);
1041 }
1042 }
1043
1044 List<ResourceBlockPermission> list = q.list();
1045
1046 if (list.size() == 2) {
1047 return list.get(1);
1048 }
1049 else {
1050 return null;
1051 }
1052 }
1053
1054
1059 @Override
1060 public void removeByRoleId(long roleId) {
1061 for (ResourceBlockPermission resourceBlockPermission : findByRoleId(
1062 roleId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1063 remove(resourceBlockPermission);
1064 }
1065 }
1066
1067
1073 @Override
1074 public int countByRoleId(long roleId) {
1075 FinderPath finderPath = FINDER_PATH_COUNT_BY_ROLEID;
1076
1077 Object[] finderArgs = new Object[] { roleId };
1078
1079 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
1080
1081 if (count == null) {
1082 StringBundler query = new StringBundler(2);
1083
1084 query.append(_SQL_COUNT_RESOURCEBLOCKPERMISSION_WHERE);
1085
1086 query.append(_FINDER_COLUMN_ROLEID_ROLEID_2);
1087
1088 String sql = query.toString();
1089
1090 Session session = null;
1091
1092 try {
1093 session = openSession();
1094
1095 Query q = session.createQuery(sql);
1096
1097 QueryPos qPos = QueryPos.getInstance(q);
1098
1099 qPos.add(roleId);
1100
1101 count = (Long)q.uniqueResult();
1102
1103 finderCache.putResult(finderPath, finderArgs, count);
1104 }
1105 catch (Exception e) {
1106 finderCache.removeResult(finderPath, finderArgs);
1107
1108 throw processException(e);
1109 }
1110 finally {
1111 closeSession(session);
1112 }
1113 }
1114
1115 return count.intValue();
1116 }
1117
1118 private static final String _FINDER_COLUMN_ROLEID_ROLEID_2 = "resourceBlockPermission.roleId = ?";
1119 public static final FinderPath FINDER_PATH_FETCH_BY_R_R = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1120 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED,
1121 ResourceBlockPermissionImpl.class, FINDER_CLASS_NAME_ENTITY,
1122 "fetchByR_R",
1123 new String[] { Long.class.getName(), Long.class.getName() },
1124 ResourceBlockPermissionModelImpl.RESOURCEBLOCKID_COLUMN_BITMASK |
1125 ResourceBlockPermissionModelImpl.ROLEID_COLUMN_BITMASK);
1126 public static final FinderPath FINDER_PATH_COUNT_BY_R_R = new FinderPath(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1127 ResourceBlockPermissionModelImpl.FINDER_CACHE_ENABLED, Long.class,
1128 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByR_R",
1129 new String[] { Long.class.getName(), Long.class.getName() });
1130
1131
1139 @Override
1140 public ResourceBlockPermission findByR_R(long resourceBlockId, long roleId)
1141 throws NoSuchResourceBlockPermissionException {
1142 ResourceBlockPermission resourceBlockPermission = fetchByR_R(resourceBlockId,
1143 roleId);
1144
1145 if (resourceBlockPermission == null) {
1146 StringBundler msg = new StringBundler(6);
1147
1148 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1149
1150 msg.append("resourceBlockId=");
1151 msg.append(resourceBlockId);
1152
1153 msg.append(", roleId=");
1154 msg.append(roleId);
1155
1156 msg.append(StringPool.CLOSE_CURLY_BRACE);
1157
1158 if (_log.isWarnEnabled()) {
1159 _log.warn(msg.toString());
1160 }
1161
1162 throw new NoSuchResourceBlockPermissionException(msg.toString());
1163 }
1164
1165 return resourceBlockPermission;
1166 }
1167
1168
1175 @Override
1176 public ResourceBlockPermission fetchByR_R(long resourceBlockId, long roleId) {
1177 return fetchByR_R(resourceBlockId, roleId, true);
1178 }
1179
1180
1188 @Override
1189 public ResourceBlockPermission fetchByR_R(long resourceBlockId,
1190 long roleId, boolean retrieveFromCache) {
1191 Object[] finderArgs = new Object[] { resourceBlockId, roleId };
1192
1193 Object result = null;
1194
1195 if (retrieveFromCache) {
1196 result = finderCache.getResult(FINDER_PATH_FETCH_BY_R_R,
1197 finderArgs, this);
1198 }
1199
1200 if (result instanceof ResourceBlockPermission) {
1201 ResourceBlockPermission resourceBlockPermission = (ResourceBlockPermission)result;
1202
1203 if ((resourceBlockId != resourceBlockPermission.getResourceBlockId()) ||
1204 (roleId != resourceBlockPermission.getRoleId())) {
1205 result = null;
1206 }
1207 }
1208
1209 if (result == null) {
1210 StringBundler query = new StringBundler(4);
1211
1212 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE);
1213
1214 query.append(_FINDER_COLUMN_R_R_RESOURCEBLOCKID_2);
1215
1216 query.append(_FINDER_COLUMN_R_R_ROLEID_2);
1217
1218 String sql = query.toString();
1219
1220 Session session = null;
1221
1222 try {
1223 session = openSession();
1224
1225 Query q = session.createQuery(sql);
1226
1227 QueryPos qPos = QueryPos.getInstance(q);
1228
1229 qPos.add(resourceBlockId);
1230
1231 qPos.add(roleId);
1232
1233 List<ResourceBlockPermission> list = q.list();
1234
1235 if (list.isEmpty()) {
1236 finderCache.putResult(FINDER_PATH_FETCH_BY_R_R, finderArgs,
1237 list);
1238 }
1239 else {
1240 ResourceBlockPermission resourceBlockPermission = list.get(0);
1241
1242 result = resourceBlockPermission;
1243
1244 cacheResult(resourceBlockPermission);
1245
1246 if ((resourceBlockPermission.getResourceBlockId() != resourceBlockId) ||
1247 (resourceBlockPermission.getRoleId() != roleId)) {
1248 finderCache.putResult(FINDER_PATH_FETCH_BY_R_R,
1249 finderArgs, resourceBlockPermission);
1250 }
1251 }
1252 }
1253 catch (Exception e) {
1254 finderCache.removeResult(FINDER_PATH_FETCH_BY_R_R, finderArgs);
1255
1256 throw processException(e);
1257 }
1258 finally {
1259 closeSession(session);
1260 }
1261 }
1262
1263 if (result instanceof List<?>) {
1264 return null;
1265 }
1266 else {
1267 return (ResourceBlockPermission)result;
1268 }
1269 }
1270
1271
1278 @Override
1279 public ResourceBlockPermission removeByR_R(long resourceBlockId, long roleId)
1280 throws NoSuchResourceBlockPermissionException {
1281 ResourceBlockPermission resourceBlockPermission = findByR_R(resourceBlockId,
1282 roleId);
1283
1284 return remove(resourceBlockPermission);
1285 }
1286
1287
1294 @Override
1295 public int countByR_R(long resourceBlockId, long roleId) {
1296 FinderPath finderPath = FINDER_PATH_COUNT_BY_R_R;
1297
1298 Object[] finderArgs = new Object[] { resourceBlockId, roleId };
1299
1300 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
1301
1302 if (count == null) {
1303 StringBundler query = new StringBundler(3);
1304
1305 query.append(_SQL_COUNT_RESOURCEBLOCKPERMISSION_WHERE);
1306
1307 query.append(_FINDER_COLUMN_R_R_RESOURCEBLOCKID_2);
1308
1309 query.append(_FINDER_COLUMN_R_R_ROLEID_2);
1310
1311 String sql = query.toString();
1312
1313 Session session = null;
1314
1315 try {
1316 session = openSession();
1317
1318 Query q = session.createQuery(sql);
1319
1320 QueryPos qPos = QueryPos.getInstance(q);
1321
1322 qPos.add(resourceBlockId);
1323
1324 qPos.add(roleId);
1325
1326 count = (Long)q.uniqueResult();
1327
1328 finderCache.putResult(finderPath, finderArgs, count);
1329 }
1330 catch (Exception e) {
1331 finderCache.removeResult(finderPath, finderArgs);
1332
1333 throw processException(e);
1334 }
1335 finally {
1336 closeSession(session);
1337 }
1338 }
1339
1340 return count.intValue();
1341 }
1342
1343 private static final String _FINDER_COLUMN_R_R_RESOURCEBLOCKID_2 = "resourceBlockPermission.resourceBlockId = ? AND ";
1344 private static final String _FINDER_COLUMN_R_R_ROLEID_2 = "resourceBlockPermission.roleId = ?";
1345
1346 public ResourceBlockPermissionPersistenceImpl() {
1347 setModelClass(ResourceBlockPermission.class);
1348 }
1349
1350
1355 @Override
1356 public void cacheResult(ResourceBlockPermission resourceBlockPermission) {
1357 entityCache.putResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1358 ResourceBlockPermissionImpl.class,
1359 resourceBlockPermission.getPrimaryKey(), resourceBlockPermission);
1360
1361 finderCache.putResult(FINDER_PATH_FETCH_BY_R_R,
1362 new Object[] {
1363 resourceBlockPermission.getResourceBlockId(),
1364 resourceBlockPermission.getRoleId()
1365 }, resourceBlockPermission);
1366
1367 resourceBlockPermission.resetOriginalValues();
1368 }
1369
1370
1375 @Override
1376 public void cacheResult(
1377 List<ResourceBlockPermission> resourceBlockPermissions) {
1378 for (ResourceBlockPermission resourceBlockPermission : resourceBlockPermissions) {
1379 if (entityCache.getResult(
1380 ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1381 ResourceBlockPermissionImpl.class,
1382 resourceBlockPermission.getPrimaryKey()) == null) {
1383 cacheResult(resourceBlockPermission);
1384 }
1385 else {
1386 resourceBlockPermission.resetOriginalValues();
1387 }
1388 }
1389 }
1390
1391
1398 @Override
1399 public void clearCache() {
1400 entityCache.clearCache(ResourceBlockPermissionImpl.class);
1401
1402 finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
1403 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1404 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1405 }
1406
1407
1414 @Override
1415 public void clearCache(ResourceBlockPermission resourceBlockPermission) {
1416 entityCache.removeResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1417 ResourceBlockPermissionImpl.class,
1418 resourceBlockPermission.getPrimaryKey());
1419
1420 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1421 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1422
1423 clearUniqueFindersCache((ResourceBlockPermissionModelImpl)resourceBlockPermission);
1424 }
1425
1426 @Override
1427 public void clearCache(
1428 List<ResourceBlockPermission> resourceBlockPermissions) {
1429 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1430 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1431
1432 for (ResourceBlockPermission resourceBlockPermission : resourceBlockPermissions) {
1433 entityCache.removeResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1434 ResourceBlockPermissionImpl.class,
1435 resourceBlockPermission.getPrimaryKey());
1436
1437 clearUniqueFindersCache((ResourceBlockPermissionModelImpl)resourceBlockPermission);
1438 }
1439 }
1440
1441 protected void cacheUniqueFindersCache(
1442 ResourceBlockPermissionModelImpl resourceBlockPermissionModelImpl,
1443 boolean isNew) {
1444 if (isNew) {
1445 Object[] args = new Object[] {
1446 resourceBlockPermissionModelImpl.getResourceBlockId(),
1447 resourceBlockPermissionModelImpl.getRoleId()
1448 };
1449
1450 finderCache.putResult(FINDER_PATH_COUNT_BY_R_R, args,
1451 Long.valueOf(1));
1452 finderCache.putResult(FINDER_PATH_FETCH_BY_R_R, args,
1453 resourceBlockPermissionModelImpl);
1454 }
1455 else {
1456 if ((resourceBlockPermissionModelImpl.getColumnBitmask() &
1457 FINDER_PATH_FETCH_BY_R_R.getColumnBitmask()) != 0) {
1458 Object[] args = new Object[] {
1459 resourceBlockPermissionModelImpl.getResourceBlockId(),
1460 resourceBlockPermissionModelImpl.getRoleId()
1461 };
1462
1463 finderCache.putResult(FINDER_PATH_COUNT_BY_R_R, args,
1464 Long.valueOf(1));
1465 finderCache.putResult(FINDER_PATH_FETCH_BY_R_R, args,
1466 resourceBlockPermissionModelImpl);
1467 }
1468 }
1469 }
1470
1471 protected void clearUniqueFindersCache(
1472 ResourceBlockPermissionModelImpl resourceBlockPermissionModelImpl) {
1473 Object[] args = new Object[] {
1474 resourceBlockPermissionModelImpl.getResourceBlockId(),
1475 resourceBlockPermissionModelImpl.getRoleId()
1476 };
1477
1478 finderCache.removeResult(FINDER_PATH_COUNT_BY_R_R, args);
1479 finderCache.removeResult(FINDER_PATH_FETCH_BY_R_R, args);
1480
1481 if ((resourceBlockPermissionModelImpl.getColumnBitmask() &
1482 FINDER_PATH_FETCH_BY_R_R.getColumnBitmask()) != 0) {
1483 args = new Object[] {
1484 resourceBlockPermissionModelImpl.getOriginalResourceBlockId(),
1485 resourceBlockPermissionModelImpl.getOriginalRoleId()
1486 };
1487
1488 finderCache.removeResult(FINDER_PATH_COUNT_BY_R_R, args);
1489 finderCache.removeResult(FINDER_PATH_FETCH_BY_R_R, args);
1490 }
1491 }
1492
1493
1499 @Override
1500 public ResourceBlockPermission create(long resourceBlockPermissionId) {
1501 ResourceBlockPermission resourceBlockPermission = new ResourceBlockPermissionImpl();
1502
1503 resourceBlockPermission.setNew(true);
1504 resourceBlockPermission.setPrimaryKey(resourceBlockPermissionId);
1505
1506 return resourceBlockPermission;
1507 }
1508
1509
1516 @Override
1517 public ResourceBlockPermission remove(long resourceBlockPermissionId)
1518 throws NoSuchResourceBlockPermissionException {
1519 return remove((Serializable)resourceBlockPermissionId);
1520 }
1521
1522
1529 @Override
1530 public ResourceBlockPermission remove(Serializable primaryKey)
1531 throws NoSuchResourceBlockPermissionException {
1532 Session session = null;
1533
1534 try {
1535 session = openSession();
1536
1537 ResourceBlockPermission resourceBlockPermission = (ResourceBlockPermission)session.get(ResourceBlockPermissionImpl.class,
1538 primaryKey);
1539
1540 if (resourceBlockPermission == null) {
1541 if (_log.isWarnEnabled()) {
1542 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
1543 }
1544
1545 throw new NoSuchResourceBlockPermissionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
1546 primaryKey);
1547 }
1548
1549 return remove(resourceBlockPermission);
1550 }
1551 catch (NoSuchResourceBlockPermissionException nsee) {
1552 throw nsee;
1553 }
1554 catch (Exception e) {
1555 throw processException(e);
1556 }
1557 finally {
1558 closeSession(session);
1559 }
1560 }
1561
1562 @Override
1563 protected ResourceBlockPermission removeImpl(
1564 ResourceBlockPermission resourceBlockPermission) {
1565 resourceBlockPermission = toUnwrappedModel(resourceBlockPermission);
1566
1567 Session session = null;
1568
1569 try {
1570 session = openSession();
1571
1572 if (!session.contains(resourceBlockPermission)) {
1573 resourceBlockPermission = (ResourceBlockPermission)session.get(ResourceBlockPermissionImpl.class,
1574 resourceBlockPermission.getPrimaryKeyObj());
1575 }
1576
1577 if (resourceBlockPermission != null) {
1578 session.delete(resourceBlockPermission);
1579 }
1580 }
1581 catch (Exception e) {
1582 throw processException(e);
1583 }
1584 finally {
1585 closeSession(session);
1586 }
1587
1588 if (resourceBlockPermission != null) {
1589 clearCache(resourceBlockPermission);
1590 }
1591
1592 return resourceBlockPermission;
1593 }
1594
1595 @Override
1596 public ResourceBlockPermission updateImpl(
1597 ResourceBlockPermission resourceBlockPermission) {
1598 resourceBlockPermission = toUnwrappedModel(resourceBlockPermission);
1599
1600 boolean isNew = resourceBlockPermission.isNew();
1601
1602 ResourceBlockPermissionModelImpl resourceBlockPermissionModelImpl = (ResourceBlockPermissionModelImpl)resourceBlockPermission;
1603
1604 Session session = null;
1605
1606 try {
1607 session = openSession();
1608
1609 if (resourceBlockPermission.isNew()) {
1610 session.save(resourceBlockPermission);
1611
1612 resourceBlockPermission.setNew(false);
1613 }
1614 else {
1615 resourceBlockPermission = (ResourceBlockPermission)session.merge(resourceBlockPermission);
1616 }
1617 }
1618 catch (Exception e) {
1619 throw processException(e);
1620 }
1621 finally {
1622 closeSession(session);
1623 }
1624
1625 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1626
1627 if (isNew || !ResourceBlockPermissionModelImpl.COLUMN_BITMASK_ENABLED) {
1628 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1629 }
1630
1631 else {
1632 if ((resourceBlockPermissionModelImpl.getColumnBitmask() &
1633 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_RESOURCEBLOCKID.getColumnBitmask()) != 0) {
1634 Object[] args = new Object[] {
1635 resourceBlockPermissionModelImpl.getOriginalResourceBlockId()
1636 };
1637
1638 finderCache.removeResult(FINDER_PATH_COUNT_BY_RESOURCEBLOCKID,
1639 args);
1640 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_RESOURCEBLOCKID,
1641 args);
1642
1643 args = new Object[] {
1644 resourceBlockPermissionModelImpl.getResourceBlockId()
1645 };
1646
1647 finderCache.removeResult(FINDER_PATH_COUNT_BY_RESOURCEBLOCKID,
1648 args);
1649 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_RESOURCEBLOCKID,
1650 args);
1651 }
1652
1653 if ((resourceBlockPermissionModelImpl.getColumnBitmask() &
1654 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROLEID.getColumnBitmask()) != 0) {
1655 Object[] args = new Object[] {
1656 resourceBlockPermissionModelImpl.getOriginalRoleId()
1657 };
1658
1659 finderCache.removeResult(FINDER_PATH_COUNT_BY_ROLEID, args);
1660 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROLEID,
1661 args);
1662
1663 args = new Object[] { resourceBlockPermissionModelImpl.getRoleId() };
1664
1665 finderCache.removeResult(FINDER_PATH_COUNT_BY_ROLEID, args);
1666 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROLEID,
1667 args);
1668 }
1669 }
1670
1671 entityCache.putResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1672 ResourceBlockPermissionImpl.class,
1673 resourceBlockPermission.getPrimaryKey(), resourceBlockPermission,
1674 false);
1675
1676 clearUniqueFindersCache(resourceBlockPermissionModelImpl);
1677 cacheUniqueFindersCache(resourceBlockPermissionModelImpl, isNew);
1678
1679 resourceBlockPermission.resetOriginalValues();
1680
1681 return resourceBlockPermission;
1682 }
1683
1684 protected ResourceBlockPermission toUnwrappedModel(
1685 ResourceBlockPermission resourceBlockPermission) {
1686 if (resourceBlockPermission instanceof ResourceBlockPermissionImpl) {
1687 return resourceBlockPermission;
1688 }
1689
1690 ResourceBlockPermissionImpl resourceBlockPermissionImpl = new ResourceBlockPermissionImpl();
1691
1692 resourceBlockPermissionImpl.setNew(resourceBlockPermission.isNew());
1693 resourceBlockPermissionImpl.setPrimaryKey(resourceBlockPermission.getPrimaryKey());
1694
1695 resourceBlockPermissionImpl.setMvccVersion(resourceBlockPermission.getMvccVersion());
1696 resourceBlockPermissionImpl.setResourceBlockPermissionId(resourceBlockPermission.getResourceBlockPermissionId());
1697 resourceBlockPermissionImpl.setResourceBlockId(resourceBlockPermission.getResourceBlockId());
1698 resourceBlockPermissionImpl.setRoleId(resourceBlockPermission.getRoleId());
1699 resourceBlockPermissionImpl.setActionIds(resourceBlockPermission.getActionIds());
1700
1701 return resourceBlockPermissionImpl;
1702 }
1703
1704
1711 @Override
1712 public ResourceBlockPermission findByPrimaryKey(Serializable primaryKey)
1713 throws NoSuchResourceBlockPermissionException {
1714 ResourceBlockPermission resourceBlockPermission = fetchByPrimaryKey(primaryKey);
1715
1716 if (resourceBlockPermission == null) {
1717 if (_log.isWarnEnabled()) {
1718 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
1719 }
1720
1721 throw new NoSuchResourceBlockPermissionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
1722 primaryKey);
1723 }
1724
1725 return resourceBlockPermission;
1726 }
1727
1728
1735 @Override
1736 public ResourceBlockPermission findByPrimaryKey(
1737 long resourceBlockPermissionId)
1738 throws NoSuchResourceBlockPermissionException {
1739 return findByPrimaryKey((Serializable)resourceBlockPermissionId);
1740 }
1741
1742
1748 @Override
1749 public ResourceBlockPermission fetchByPrimaryKey(Serializable primaryKey) {
1750 ResourceBlockPermission resourceBlockPermission = (ResourceBlockPermission)entityCache.getResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1751 ResourceBlockPermissionImpl.class, primaryKey);
1752
1753 if (resourceBlockPermission == _nullResourceBlockPermission) {
1754 return null;
1755 }
1756
1757 if (resourceBlockPermission == null) {
1758 Session session = null;
1759
1760 try {
1761 session = openSession();
1762
1763 resourceBlockPermission = (ResourceBlockPermission)session.get(ResourceBlockPermissionImpl.class,
1764 primaryKey);
1765
1766 if (resourceBlockPermission != null) {
1767 cacheResult(resourceBlockPermission);
1768 }
1769 else {
1770 entityCache.putResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1771 ResourceBlockPermissionImpl.class, primaryKey,
1772 _nullResourceBlockPermission);
1773 }
1774 }
1775 catch (Exception e) {
1776 entityCache.removeResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1777 ResourceBlockPermissionImpl.class, primaryKey);
1778
1779 throw processException(e);
1780 }
1781 finally {
1782 closeSession(session);
1783 }
1784 }
1785
1786 return resourceBlockPermission;
1787 }
1788
1789
1795 @Override
1796 public ResourceBlockPermission fetchByPrimaryKey(
1797 long resourceBlockPermissionId) {
1798 return fetchByPrimaryKey((Serializable)resourceBlockPermissionId);
1799 }
1800
1801 @Override
1802 public Map<Serializable, ResourceBlockPermission> fetchByPrimaryKeys(
1803 Set<Serializable> primaryKeys) {
1804 if (primaryKeys.isEmpty()) {
1805 return Collections.emptyMap();
1806 }
1807
1808 Map<Serializable, ResourceBlockPermission> map = new HashMap<Serializable, ResourceBlockPermission>();
1809
1810 if (primaryKeys.size() == 1) {
1811 Iterator<Serializable> iterator = primaryKeys.iterator();
1812
1813 Serializable primaryKey = iterator.next();
1814
1815 ResourceBlockPermission resourceBlockPermission = fetchByPrimaryKey(primaryKey);
1816
1817 if (resourceBlockPermission != null) {
1818 map.put(primaryKey, resourceBlockPermission);
1819 }
1820
1821 return map;
1822 }
1823
1824 Set<Serializable> uncachedPrimaryKeys = null;
1825
1826 for (Serializable primaryKey : primaryKeys) {
1827 ResourceBlockPermission resourceBlockPermission = (ResourceBlockPermission)entityCache.getResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1828 ResourceBlockPermissionImpl.class, primaryKey);
1829
1830 if (resourceBlockPermission == null) {
1831 if (uncachedPrimaryKeys == null) {
1832 uncachedPrimaryKeys = new HashSet<Serializable>();
1833 }
1834
1835 uncachedPrimaryKeys.add(primaryKey);
1836 }
1837 else {
1838 map.put(primaryKey, resourceBlockPermission);
1839 }
1840 }
1841
1842 if (uncachedPrimaryKeys == null) {
1843 return map;
1844 }
1845
1846 StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) +
1847 1);
1848
1849 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE_PKS_IN);
1850
1851 for (Serializable primaryKey : uncachedPrimaryKeys) {
1852 query.append(String.valueOf(primaryKey));
1853
1854 query.append(StringPool.COMMA);
1855 }
1856
1857 query.setIndex(query.index() - 1);
1858
1859 query.append(StringPool.CLOSE_PARENTHESIS);
1860
1861 String sql = query.toString();
1862
1863 Session session = null;
1864
1865 try {
1866 session = openSession();
1867
1868 Query q = session.createQuery(sql);
1869
1870 for (ResourceBlockPermission resourceBlockPermission : (List<ResourceBlockPermission>)q.list()) {
1871 map.put(resourceBlockPermission.getPrimaryKeyObj(),
1872 resourceBlockPermission);
1873
1874 cacheResult(resourceBlockPermission);
1875
1876 uncachedPrimaryKeys.remove(resourceBlockPermission.getPrimaryKeyObj());
1877 }
1878
1879 for (Serializable primaryKey : uncachedPrimaryKeys) {
1880 entityCache.putResult(ResourceBlockPermissionModelImpl.ENTITY_CACHE_ENABLED,
1881 ResourceBlockPermissionImpl.class, primaryKey,
1882 _nullResourceBlockPermission);
1883 }
1884 }
1885 catch (Exception e) {
1886 throw processException(e);
1887 }
1888 finally {
1889 closeSession(session);
1890 }
1891
1892 return map;
1893 }
1894
1895
1900 @Override
1901 public List<ResourceBlockPermission> findAll() {
1902 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1903 }
1904
1905
1916 @Override
1917 public List<ResourceBlockPermission> findAll(int start, int end) {
1918 return findAll(start, end, null);
1919 }
1920
1921
1933 @Override
1934 public List<ResourceBlockPermission> findAll(int start, int end,
1935 OrderByComparator<ResourceBlockPermission> orderByComparator) {
1936 return findAll(start, end, orderByComparator, true);
1937 }
1938
1939
1952 @Override
1953 public List<ResourceBlockPermission> findAll(int start, int end,
1954 OrderByComparator<ResourceBlockPermission> orderByComparator,
1955 boolean retrieveFromCache) {
1956 boolean pagination = true;
1957 FinderPath finderPath = null;
1958 Object[] finderArgs = null;
1959
1960 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1961 (orderByComparator == null)) {
1962 pagination = false;
1963 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
1964 finderArgs = FINDER_ARGS_EMPTY;
1965 }
1966 else {
1967 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
1968 finderArgs = new Object[] { start, end, orderByComparator };
1969 }
1970
1971 List<ResourceBlockPermission> list = null;
1972
1973 if (retrieveFromCache) {
1974 list = (List<ResourceBlockPermission>)finderCache.getResult(finderPath,
1975 finderArgs, this);
1976 }
1977
1978 if (list == null) {
1979 StringBundler query = null;
1980 String sql = null;
1981
1982 if (orderByComparator != null) {
1983 query = new StringBundler(2 +
1984 (orderByComparator.getOrderByFields().length * 3));
1985
1986 query.append(_SQL_SELECT_RESOURCEBLOCKPERMISSION);
1987
1988 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1989 orderByComparator);
1990
1991 sql = query.toString();
1992 }
1993 else {
1994 sql = _SQL_SELECT_RESOURCEBLOCKPERMISSION;
1995
1996 if (pagination) {
1997 sql = sql.concat(ResourceBlockPermissionModelImpl.ORDER_BY_JPQL);
1998 }
1999 }
2000
2001 Session session = null;
2002
2003 try {
2004 session = openSession();
2005
2006 Query q = session.createQuery(sql);
2007
2008 if (!pagination) {
2009 list = (List<ResourceBlockPermission>)QueryUtil.list(q,
2010 getDialect(), start, end, false);
2011
2012 Collections.sort(list);
2013
2014 list = Collections.unmodifiableList(list);
2015 }
2016 else {
2017 list = (List<ResourceBlockPermission>)QueryUtil.list(q,
2018 getDialect(), start, end);
2019 }
2020
2021 cacheResult(list);
2022
2023 finderCache.putResult(finderPath, finderArgs, list);
2024 }
2025 catch (Exception e) {
2026 finderCache.removeResult(finderPath, finderArgs);
2027
2028 throw processException(e);
2029 }
2030 finally {
2031 closeSession(session);
2032 }
2033 }
2034
2035 return list;
2036 }
2037
2038
2042 @Override
2043 public void removeAll() {
2044 for (ResourceBlockPermission resourceBlockPermission : findAll()) {
2045 remove(resourceBlockPermission);
2046 }
2047 }
2048
2049
2054 @Override
2055 public int countAll() {
2056 Long count = (Long)finderCache.getResult(FINDER_PATH_COUNT_ALL,
2057 FINDER_ARGS_EMPTY, this);
2058
2059 if (count == null) {
2060 Session session = null;
2061
2062 try {
2063 session = openSession();
2064
2065 Query q = session.createQuery(_SQL_COUNT_RESOURCEBLOCKPERMISSION);
2066
2067 count = (Long)q.uniqueResult();
2068
2069 finderCache.putResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY,
2070 count);
2071 }
2072 catch (Exception e) {
2073 finderCache.removeResult(FINDER_PATH_COUNT_ALL,
2074 FINDER_ARGS_EMPTY);
2075
2076 throw processException(e);
2077 }
2078 finally {
2079 closeSession(session);
2080 }
2081 }
2082
2083 return count.intValue();
2084 }
2085
2086 @Override
2087 protected Map<String, Integer> getTableColumnsMap() {
2088 return ResourceBlockPermissionModelImpl.TABLE_COLUMNS_MAP;
2089 }
2090
2091
2094 public void afterPropertiesSet() {
2095 }
2096
2097 public void destroy() {
2098 entityCache.removeCache(ResourceBlockPermissionImpl.class.getName());
2099 finderCache.removeCache(FINDER_CLASS_NAME_ENTITY);
2100 finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2101 finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2102 }
2103
2104 protected EntityCache entityCache = EntityCacheUtil.getEntityCache();
2105 protected FinderCache finderCache = FinderCacheUtil.getFinderCache();
2106 private static final String _SQL_SELECT_RESOURCEBLOCKPERMISSION = "SELECT resourceBlockPermission FROM ResourceBlockPermission resourceBlockPermission";
2107 private static final String _SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE_PKS_IN =
2108 "SELECT resourceBlockPermission FROM ResourceBlockPermission resourceBlockPermission WHERE resourceBlockPermissionId IN (";
2109 private static final String _SQL_SELECT_RESOURCEBLOCKPERMISSION_WHERE = "SELECT resourceBlockPermission FROM ResourceBlockPermission resourceBlockPermission WHERE ";
2110 private static final String _SQL_COUNT_RESOURCEBLOCKPERMISSION = "SELECT COUNT(resourceBlockPermission) FROM ResourceBlockPermission resourceBlockPermission";
2111 private static final String _SQL_COUNT_RESOURCEBLOCKPERMISSION_WHERE = "SELECT COUNT(resourceBlockPermission) FROM ResourceBlockPermission resourceBlockPermission WHERE ";
2112 private static final String _ORDER_BY_ENTITY_ALIAS = "resourceBlockPermission.";
2113 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ResourceBlockPermission exists with the primary key ";
2114 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ResourceBlockPermission exists with the key {";
2115 private static final Log _log = LogFactoryUtil.getLog(ResourceBlockPermissionPersistenceImpl.class);
2116 private static final ResourceBlockPermission _nullResourceBlockPermission = new ResourceBlockPermissionImpl() {
2117 @Override
2118 public Object clone() {
2119 return this;
2120 }
2121
2122 @Override
2123 public CacheModel<ResourceBlockPermission> toCacheModel() {
2124 return _nullResourceBlockPermissionCacheModel;
2125 }
2126 };
2127
2128 private static final CacheModel<ResourceBlockPermission> _nullResourceBlockPermissionCacheModel =
2129 new NullCacheModel();
2130
2131 private static class NullCacheModel implements CacheModel<ResourceBlockPermission>,
2132 MVCCModel {
2133 @Override
2134 public long getMvccVersion() {
2135 return -1;
2136 }
2137
2138 @Override
2139 public void setMvccVersion(long mvccVersion) {
2140 }
2141
2142 @Override
2143 public ResourceBlockPermission toEntityModel() {
2144 return _nullResourceBlockPermission;
2145 }
2146 }
2147 }