001
014
015 package com.liferay.portlet.journal.service.persistence;
016
017 import com.liferay.portal.kernel.cache.CacheRegistryUtil;
018 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
019 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
020 import com.liferay.portal.kernel.dao.orm.FinderPath;
021 import com.liferay.portal.kernel.dao.orm.Query;
022 import com.liferay.portal.kernel.dao.orm.QueryPos;
023 import com.liferay.portal.kernel.dao.orm.QueryUtil;
024 import com.liferay.portal.kernel.dao.orm.Session;
025 import com.liferay.portal.kernel.exception.SystemException;
026 import com.liferay.portal.kernel.log.Log;
027 import com.liferay.portal.kernel.log.LogFactoryUtil;
028 import com.liferay.portal.kernel.util.GetterUtil;
029 import com.liferay.portal.kernel.util.InstanceFactory;
030 import com.liferay.portal.kernel.util.OrderByComparator;
031 import com.liferay.portal.kernel.util.SetUtil;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.UnmodifiableList;
036 import com.liferay.portal.kernel.util.Validator;
037 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
038 import com.liferay.portal.model.CacheModel;
039 import com.liferay.portal.model.ModelListener;
040 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
041
042 import com.liferay.portlet.journal.NoSuchArticleResourceException;
043 import com.liferay.portlet.journal.model.JournalArticleResource;
044 import com.liferay.portlet.journal.model.impl.JournalArticleResourceImpl;
045 import com.liferay.portlet.journal.model.impl.JournalArticleResourceModelImpl;
046
047 import java.io.Serializable;
048
049 import java.util.ArrayList;
050 import java.util.Collections;
051 import java.util.List;
052 import java.util.Set;
053
054
066 public class JournalArticleResourcePersistenceImpl extends BasePersistenceImpl<JournalArticleResource>
067 implements JournalArticleResourcePersistence {
068
073 public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleResourceImpl.class.getName();
074 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
075 ".List1";
076 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
077 ".List2";
078 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
079 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
080 JournalArticleResourceImpl.class,
081 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
082 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
083 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
084 JournalArticleResourceImpl.class,
085 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
086 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
087 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
088 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
089 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
090 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
091 JournalArticleResourceImpl.class,
092 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
093 new String[] {
094 String.class.getName(),
095
096 Integer.class.getName(), Integer.class.getName(),
097 OrderByComparator.class.getName()
098 });
099 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
100 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
101 JournalArticleResourceImpl.class,
102 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
103 new String[] { String.class.getName() },
104 JournalArticleResourceModelImpl.UUID_COLUMN_BITMASK);
105 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
106 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
107 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
108 new String[] { String.class.getName() });
109
110
117 @Override
118 public List<JournalArticleResource> findByUuid(String uuid)
119 throws SystemException {
120 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
121 }
122
123
136 @Override
137 public List<JournalArticleResource> findByUuid(String uuid, int start,
138 int end) throws SystemException {
139 return findByUuid(uuid, start, end, null);
140 }
141
142
156 @Override
157 public List<JournalArticleResource> findByUuid(String uuid, int start,
158 int end, OrderByComparator orderByComparator) throws SystemException {
159 boolean pagination = true;
160 FinderPath finderPath = null;
161 Object[] finderArgs = null;
162
163 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
164 (orderByComparator == null)) {
165 pagination = false;
166 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
167 finderArgs = new Object[] { uuid };
168 }
169 else {
170 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
171 finderArgs = new Object[] { uuid, start, end, orderByComparator };
172 }
173
174 List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
175 finderArgs, this);
176
177 if ((list != null) && !list.isEmpty()) {
178 for (JournalArticleResource journalArticleResource : list) {
179 if (!Validator.equals(uuid, journalArticleResource.getUuid())) {
180 list = null;
181
182 break;
183 }
184 }
185 }
186
187 if (list == null) {
188 StringBundler query = null;
189
190 if (orderByComparator != null) {
191 query = new StringBundler(3 +
192 (orderByComparator.getOrderByFields().length * 3));
193 }
194 else {
195 query = new StringBundler(3);
196 }
197
198 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
199
200 boolean bindUuid = false;
201
202 if (uuid == null) {
203 query.append(_FINDER_COLUMN_UUID_UUID_1);
204 }
205 else if (uuid.equals(StringPool.BLANK)) {
206 query.append(_FINDER_COLUMN_UUID_UUID_3);
207 }
208 else {
209 bindUuid = true;
210
211 query.append(_FINDER_COLUMN_UUID_UUID_2);
212 }
213
214 if (orderByComparator != null) {
215 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
216 orderByComparator);
217 }
218 else
219 if (pagination) {
220 query.append(JournalArticleResourceModelImpl.ORDER_BY_JPQL);
221 }
222
223 String sql = query.toString();
224
225 Session session = null;
226
227 try {
228 session = openSession();
229
230 Query q = session.createQuery(sql);
231
232 QueryPos qPos = QueryPos.getInstance(q);
233
234 if (bindUuid) {
235 qPos.add(uuid);
236 }
237
238 if (!pagination) {
239 list = (List<JournalArticleResource>)QueryUtil.list(q,
240 getDialect(), start, end, false);
241
242 Collections.sort(list);
243
244 list = new UnmodifiableList<JournalArticleResource>(list);
245 }
246 else {
247 list = (List<JournalArticleResource>)QueryUtil.list(q,
248 getDialect(), start, end);
249 }
250
251 cacheResult(list);
252
253 FinderCacheUtil.putResult(finderPath, finderArgs, list);
254 }
255 catch (Exception e) {
256 FinderCacheUtil.removeResult(finderPath, finderArgs);
257
258 throw processException(e);
259 }
260 finally {
261 closeSession(session);
262 }
263 }
264
265 return list;
266 }
267
268
277 @Override
278 public JournalArticleResource findByUuid_First(String uuid,
279 OrderByComparator orderByComparator)
280 throws NoSuchArticleResourceException, SystemException {
281 JournalArticleResource journalArticleResource = fetchByUuid_First(uuid,
282 orderByComparator);
283
284 if (journalArticleResource != null) {
285 return journalArticleResource;
286 }
287
288 StringBundler msg = new StringBundler(4);
289
290 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
291
292 msg.append("uuid=");
293 msg.append(uuid);
294
295 msg.append(StringPool.CLOSE_CURLY_BRACE);
296
297 throw new NoSuchArticleResourceException(msg.toString());
298 }
299
300
308 @Override
309 public JournalArticleResource fetchByUuid_First(String uuid,
310 OrderByComparator orderByComparator) throws SystemException {
311 List<JournalArticleResource> list = findByUuid(uuid, 0, 1,
312 orderByComparator);
313
314 if (!list.isEmpty()) {
315 return list.get(0);
316 }
317
318 return null;
319 }
320
321
330 @Override
331 public JournalArticleResource findByUuid_Last(String uuid,
332 OrderByComparator orderByComparator)
333 throws NoSuchArticleResourceException, SystemException {
334 JournalArticleResource journalArticleResource = fetchByUuid_Last(uuid,
335 orderByComparator);
336
337 if (journalArticleResource != null) {
338 return journalArticleResource;
339 }
340
341 StringBundler msg = new StringBundler(4);
342
343 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
344
345 msg.append("uuid=");
346 msg.append(uuid);
347
348 msg.append(StringPool.CLOSE_CURLY_BRACE);
349
350 throw new NoSuchArticleResourceException(msg.toString());
351 }
352
353
361 @Override
362 public JournalArticleResource fetchByUuid_Last(String uuid,
363 OrderByComparator orderByComparator) throws SystemException {
364 int count = countByUuid(uuid);
365
366 if (count == 0) {
367 return null;
368 }
369
370 List<JournalArticleResource> list = findByUuid(uuid, count - 1, count,
371 orderByComparator);
372
373 if (!list.isEmpty()) {
374 return list.get(0);
375 }
376
377 return null;
378 }
379
380
390 @Override
391 public JournalArticleResource[] findByUuid_PrevAndNext(
392 long resourcePrimKey, String uuid, OrderByComparator orderByComparator)
393 throws NoSuchArticleResourceException, SystemException {
394 JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
395
396 Session session = null;
397
398 try {
399 session = openSession();
400
401 JournalArticleResource[] array = new JournalArticleResourceImpl[3];
402
403 array[0] = getByUuid_PrevAndNext(session, journalArticleResource,
404 uuid, orderByComparator, true);
405
406 array[1] = journalArticleResource;
407
408 array[2] = getByUuid_PrevAndNext(session, journalArticleResource,
409 uuid, orderByComparator, false);
410
411 return array;
412 }
413 catch (Exception e) {
414 throw processException(e);
415 }
416 finally {
417 closeSession(session);
418 }
419 }
420
421 protected JournalArticleResource getByUuid_PrevAndNext(Session session,
422 JournalArticleResource journalArticleResource, String uuid,
423 OrderByComparator orderByComparator, boolean previous) {
424 StringBundler query = null;
425
426 if (orderByComparator != null) {
427 query = new StringBundler(6 +
428 (orderByComparator.getOrderByFields().length * 6));
429 }
430 else {
431 query = new StringBundler(3);
432 }
433
434 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
435
436 boolean bindUuid = false;
437
438 if (uuid == null) {
439 query.append(_FINDER_COLUMN_UUID_UUID_1);
440 }
441 else if (uuid.equals(StringPool.BLANK)) {
442 query.append(_FINDER_COLUMN_UUID_UUID_3);
443 }
444 else {
445 bindUuid = true;
446
447 query.append(_FINDER_COLUMN_UUID_UUID_2);
448 }
449
450 if (orderByComparator != null) {
451 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
452
453 if (orderByConditionFields.length > 0) {
454 query.append(WHERE_AND);
455 }
456
457 for (int i = 0; i < orderByConditionFields.length; i++) {
458 query.append(_ORDER_BY_ENTITY_ALIAS);
459 query.append(orderByConditionFields[i]);
460
461 if ((i + 1) < orderByConditionFields.length) {
462 if (orderByComparator.isAscending() ^ previous) {
463 query.append(WHERE_GREATER_THAN_HAS_NEXT);
464 }
465 else {
466 query.append(WHERE_LESSER_THAN_HAS_NEXT);
467 }
468 }
469 else {
470 if (orderByComparator.isAscending() ^ previous) {
471 query.append(WHERE_GREATER_THAN);
472 }
473 else {
474 query.append(WHERE_LESSER_THAN);
475 }
476 }
477 }
478
479 query.append(ORDER_BY_CLAUSE);
480
481 String[] orderByFields = orderByComparator.getOrderByFields();
482
483 for (int i = 0; i < orderByFields.length; i++) {
484 query.append(_ORDER_BY_ENTITY_ALIAS);
485 query.append(orderByFields[i]);
486
487 if ((i + 1) < orderByFields.length) {
488 if (orderByComparator.isAscending() ^ previous) {
489 query.append(ORDER_BY_ASC_HAS_NEXT);
490 }
491 else {
492 query.append(ORDER_BY_DESC_HAS_NEXT);
493 }
494 }
495 else {
496 if (orderByComparator.isAscending() ^ previous) {
497 query.append(ORDER_BY_ASC);
498 }
499 else {
500 query.append(ORDER_BY_DESC);
501 }
502 }
503 }
504 }
505 else {
506 query.append(JournalArticleResourceModelImpl.ORDER_BY_JPQL);
507 }
508
509 String sql = query.toString();
510
511 Query q = session.createQuery(sql);
512
513 q.setFirstResult(0);
514 q.setMaxResults(2);
515
516 QueryPos qPos = QueryPos.getInstance(q);
517
518 if (bindUuid) {
519 qPos.add(uuid);
520 }
521
522 if (orderByComparator != null) {
523 Object[] values = orderByComparator.getOrderByConditionValues(journalArticleResource);
524
525 for (Object value : values) {
526 qPos.add(value);
527 }
528 }
529
530 List<JournalArticleResource> list = q.list();
531
532 if (list.size() == 2) {
533 return list.get(1);
534 }
535 else {
536 return null;
537 }
538 }
539
540
546 @Override
547 public void removeByUuid(String uuid) throws SystemException {
548 for (JournalArticleResource journalArticleResource : findByUuid(uuid,
549 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
550 remove(journalArticleResource);
551 }
552 }
553
554
561 @Override
562 public int countByUuid(String uuid) throws SystemException {
563 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
564
565 Object[] finderArgs = new Object[] { uuid };
566
567 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
568 this);
569
570 if (count == null) {
571 StringBundler query = new StringBundler(2);
572
573 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
574
575 boolean bindUuid = false;
576
577 if (uuid == null) {
578 query.append(_FINDER_COLUMN_UUID_UUID_1);
579 }
580 else if (uuid.equals(StringPool.BLANK)) {
581 query.append(_FINDER_COLUMN_UUID_UUID_3);
582 }
583 else {
584 bindUuid = true;
585
586 query.append(_FINDER_COLUMN_UUID_UUID_2);
587 }
588
589 String sql = query.toString();
590
591 Session session = null;
592
593 try {
594 session = openSession();
595
596 Query q = session.createQuery(sql);
597
598 QueryPos qPos = QueryPos.getInstance(q);
599
600 if (bindUuid) {
601 qPos.add(uuid);
602 }
603
604 count = (Long)q.uniqueResult();
605
606 FinderCacheUtil.putResult(finderPath, finderArgs, count);
607 }
608 catch (Exception e) {
609 FinderCacheUtil.removeResult(finderPath, finderArgs);
610
611 throw processException(e);
612 }
613 finally {
614 closeSession(session);
615 }
616 }
617
618 return count.intValue();
619 }
620
621 private static final String _FINDER_COLUMN_UUID_UUID_1 = "journalArticleResource.uuid IS NULL";
622 private static final String _FINDER_COLUMN_UUID_UUID_2 = "journalArticleResource.uuid = ?";
623 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(journalArticleResource.uuid IS NULL OR journalArticleResource.uuid = '')";
624 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
625 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
626 JournalArticleResourceImpl.class, FINDER_CLASS_NAME_ENTITY,
627 "fetchByUUID_G",
628 new String[] { String.class.getName(), Long.class.getName() },
629 JournalArticleResourceModelImpl.UUID_COLUMN_BITMASK |
630 JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK);
631 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
632 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
633 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
634 new String[] { String.class.getName(), Long.class.getName() });
635
636
645 @Override
646 public JournalArticleResource findByUUID_G(String uuid, long groupId)
647 throws NoSuchArticleResourceException, SystemException {
648 JournalArticleResource journalArticleResource = fetchByUUID_G(uuid,
649 groupId);
650
651 if (journalArticleResource == null) {
652 StringBundler msg = new StringBundler(6);
653
654 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
655
656 msg.append("uuid=");
657 msg.append(uuid);
658
659 msg.append(", groupId=");
660 msg.append(groupId);
661
662 msg.append(StringPool.CLOSE_CURLY_BRACE);
663
664 if (_log.isWarnEnabled()) {
665 _log.warn(msg.toString());
666 }
667
668 throw new NoSuchArticleResourceException(msg.toString());
669 }
670
671 return journalArticleResource;
672 }
673
674
682 @Override
683 public JournalArticleResource fetchByUUID_G(String uuid, long groupId)
684 throws SystemException {
685 return fetchByUUID_G(uuid, groupId, true);
686 }
687
688
697 @Override
698 public JournalArticleResource fetchByUUID_G(String uuid, long groupId,
699 boolean retrieveFromCache) throws SystemException {
700 Object[] finderArgs = new Object[] { uuid, groupId };
701
702 Object result = null;
703
704 if (retrieveFromCache) {
705 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
706 finderArgs, this);
707 }
708
709 if (result instanceof JournalArticleResource) {
710 JournalArticleResource journalArticleResource = (JournalArticleResource)result;
711
712 if (!Validator.equals(uuid, journalArticleResource.getUuid()) ||
713 (groupId != journalArticleResource.getGroupId())) {
714 result = null;
715 }
716 }
717
718 if (result == null) {
719 StringBundler query = new StringBundler(4);
720
721 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
722
723 boolean bindUuid = false;
724
725 if (uuid == null) {
726 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
727 }
728 else if (uuid.equals(StringPool.BLANK)) {
729 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
730 }
731 else {
732 bindUuid = true;
733
734 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
735 }
736
737 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
738
739 String sql = query.toString();
740
741 Session session = null;
742
743 try {
744 session = openSession();
745
746 Query q = session.createQuery(sql);
747
748 QueryPos qPos = QueryPos.getInstance(q);
749
750 if (bindUuid) {
751 qPos.add(uuid);
752 }
753
754 qPos.add(groupId);
755
756 List<JournalArticleResource> list = q.list();
757
758 if (list.isEmpty()) {
759 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
760 finderArgs, list);
761 }
762 else {
763 JournalArticleResource journalArticleResource = list.get(0);
764
765 result = journalArticleResource;
766
767 cacheResult(journalArticleResource);
768
769 if ((journalArticleResource.getUuid() == null) ||
770 !journalArticleResource.getUuid().equals(uuid) ||
771 (journalArticleResource.getGroupId() != groupId)) {
772 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
773 finderArgs, journalArticleResource);
774 }
775 }
776 }
777 catch (Exception e) {
778 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
779 finderArgs);
780
781 throw processException(e);
782 }
783 finally {
784 closeSession(session);
785 }
786 }
787
788 if (result instanceof List<?>) {
789 return null;
790 }
791 else {
792 return (JournalArticleResource)result;
793 }
794 }
795
796
804 @Override
805 public JournalArticleResource removeByUUID_G(String uuid, long groupId)
806 throws NoSuchArticleResourceException, SystemException {
807 JournalArticleResource journalArticleResource = findByUUID_G(uuid,
808 groupId);
809
810 return remove(journalArticleResource);
811 }
812
813
821 @Override
822 public int countByUUID_G(String uuid, long groupId)
823 throws SystemException {
824 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_G;
825
826 Object[] finderArgs = new Object[] { uuid, groupId };
827
828 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
829 this);
830
831 if (count == null) {
832 StringBundler query = new StringBundler(3);
833
834 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
835
836 boolean bindUuid = false;
837
838 if (uuid == null) {
839 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
840 }
841 else if (uuid.equals(StringPool.BLANK)) {
842 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
843 }
844 else {
845 bindUuid = true;
846
847 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
848 }
849
850 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
851
852 String sql = query.toString();
853
854 Session session = null;
855
856 try {
857 session = openSession();
858
859 Query q = session.createQuery(sql);
860
861 QueryPos qPos = QueryPos.getInstance(q);
862
863 if (bindUuid) {
864 qPos.add(uuid);
865 }
866
867 qPos.add(groupId);
868
869 count = (Long)q.uniqueResult();
870
871 FinderCacheUtil.putResult(finderPath, finderArgs, count);
872 }
873 catch (Exception e) {
874 FinderCacheUtil.removeResult(finderPath, finderArgs);
875
876 throw processException(e);
877 }
878 finally {
879 closeSession(session);
880 }
881 }
882
883 return count.intValue();
884 }
885
886 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "journalArticleResource.uuid IS NULL AND ";
887 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "journalArticleResource.uuid = ? AND ";
888 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(journalArticleResource.uuid IS NULL OR journalArticleResource.uuid = '') AND ";
889 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "journalArticleResource.groupId = ?";
890 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
891 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
892 JournalArticleResourceImpl.class,
893 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
894 new String[] {
895 Long.class.getName(),
896
897 Integer.class.getName(), Integer.class.getName(),
898 OrderByComparator.class.getName()
899 });
900 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
901 new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
902 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
903 JournalArticleResourceImpl.class,
904 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
905 new String[] { Long.class.getName() },
906 JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK);
907 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
908 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
909 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
910 new String[] { Long.class.getName() });
911
912
919 @Override
920 public List<JournalArticleResource> findByGroupId(long groupId)
921 throws SystemException {
922 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
923 }
924
925
938 @Override
939 public List<JournalArticleResource> findByGroupId(long groupId, int start,
940 int end) throws SystemException {
941 return findByGroupId(groupId, start, end, null);
942 }
943
944
958 @Override
959 public List<JournalArticleResource> findByGroupId(long groupId, int start,
960 int end, OrderByComparator orderByComparator) throws SystemException {
961 boolean pagination = true;
962 FinderPath finderPath = null;
963 Object[] finderArgs = null;
964
965 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
966 (orderByComparator == null)) {
967 pagination = false;
968 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
969 finderArgs = new Object[] { groupId };
970 }
971 else {
972 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
973 finderArgs = new Object[] { groupId, start, end, orderByComparator };
974 }
975
976 List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
977 finderArgs, this);
978
979 if ((list != null) && !list.isEmpty()) {
980 for (JournalArticleResource journalArticleResource : list) {
981 if ((groupId != journalArticleResource.getGroupId())) {
982 list = null;
983
984 break;
985 }
986 }
987 }
988
989 if (list == null) {
990 StringBundler query = null;
991
992 if (orderByComparator != null) {
993 query = new StringBundler(3 +
994 (orderByComparator.getOrderByFields().length * 3));
995 }
996 else {
997 query = new StringBundler(3);
998 }
999
1000 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1001
1002 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1003
1004 if (orderByComparator != null) {
1005 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1006 orderByComparator);
1007 }
1008 else
1009 if (pagination) {
1010 query.append(JournalArticleResourceModelImpl.ORDER_BY_JPQL);
1011 }
1012
1013 String sql = query.toString();
1014
1015 Session session = null;
1016
1017 try {
1018 session = openSession();
1019
1020 Query q = session.createQuery(sql);
1021
1022 QueryPos qPos = QueryPos.getInstance(q);
1023
1024 qPos.add(groupId);
1025
1026 if (!pagination) {
1027 list = (List<JournalArticleResource>)QueryUtil.list(q,
1028 getDialect(), start, end, false);
1029
1030 Collections.sort(list);
1031
1032 list = new UnmodifiableList<JournalArticleResource>(list);
1033 }
1034 else {
1035 list = (List<JournalArticleResource>)QueryUtil.list(q,
1036 getDialect(), start, end);
1037 }
1038
1039 cacheResult(list);
1040
1041 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1042 }
1043 catch (Exception e) {
1044 FinderCacheUtil.removeResult(finderPath, finderArgs);
1045
1046 throw processException(e);
1047 }
1048 finally {
1049 closeSession(session);
1050 }
1051 }
1052
1053 return list;
1054 }
1055
1056
1065 @Override
1066 public JournalArticleResource findByGroupId_First(long groupId,
1067 OrderByComparator orderByComparator)
1068 throws NoSuchArticleResourceException, SystemException {
1069 JournalArticleResource journalArticleResource = fetchByGroupId_First(groupId,
1070 orderByComparator);
1071
1072 if (journalArticleResource != null) {
1073 return journalArticleResource;
1074 }
1075
1076 StringBundler msg = new StringBundler(4);
1077
1078 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1079
1080 msg.append("groupId=");
1081 msg.append(groupId);
1082
1083 msg.append(StringPool.CLOSE_CURLY_BRACE);
1084
1085 throw new NoSuchArticleResourceException(msg.toString());
1086 }
1087
1088
1096 @Override
1097 public JournalArticleResource fetchByGroupId_First(long groupId,
1098 OrderByComparator orderByComparator) throws SystemException {
1099 List<JournalArticleResource> list = findByGroupId(groupId, 0, 1,
1100 orderByComparator);
1101
1102 if (!list.isEmpty()) {
1103 return list.get(0);
1104 }
1105
1106 return null;
1107 }
1108
1109
1118 @Override
1119 public JournalArticleResource findByGroupId_Last(long groupId,
1120 OrderByComparator orderByComparator)
1121 throws NoSuchArticleResourceException, SystemException {
1122 JournalArticleResource journalArticleResource = fetchByGroupId_Last(groupId,
1123 orderByComparator);
1124
1125 if (journalArticleResource != null) {
1126 return journalArticleResource;
1127 }
1128
1129 StringBundler msg = new StringBundler(4);
1130
1131 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1132
1133 msg.append("groupId=");
1134 msg.append(groupId);
1135
1136 msg.append(StringPool.CLOSE_CURLY_BRACE);
1137
1138 throw new NoSuchArticleResourceException(msg.toString());
1139 }
1140
1141
1149 @Override
1150 public JournalArticleResource fetchByGroupId_Last(long groupId,
1151 OrderByComparator orderByComparator) throws SystemException {
1152 int count = countByGroupId(groupId);
1153
1154 if (count == 0) {
1155 return null;
1156 }
1157
1158 List<JournalArticleResource> list = findByGroupId(groupId, count - 1,
1159 count, orderByComparator);
1160
1161 if (!list.isEmpty()) {
1162 return list.get(0);
1163 }
1164
1165 return null;
1166 }
1167
1168
1178 @Override
1179 public JournalArticleResource[] findByGroupId_PrevAndNext(
1180 long resourcePrimKey, long groupId, OrderByComparator orderByComparator)
1181 throws NoSuchArticleResourceException, SystemException {
1182 JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
1183
1184 Session session = null;
1185
1186 try {
1187 session = openSession();
1188
1189 JournalArticleResource[] array = new JournalArticleResourceImpl[3];
1190
1191 array[0] = getByGroupId_PrevAndNext(session,
1192 journalArticleResource, groupId, orderByComparator, true);
1193
1194 array[1] = journalArticleResource;
1195
1196 array[2] = getByGroupId_PrevAndNext(session,
1197 journalArticleResource, groupId, orderByComparator, false);
1198
1199 return array;
1200 }
1201 catch (Exception e) {
1202 throw processException(e);
1203 }
1204 finally {
1205 closeSession(session);
1206 }
1207 }
1208
1209 protected JournalArticleResource getByGroupId_PrevAndNext(Session session,
1210 JournalArticleResource journalArticleResource, long groupId,
1211 OrderByComparator orderByComparator, boolean previous) {
1212 StringBundler query = null;
1213
1214 if (orderByComparator != null) {
1215 query = new StringBundler(6 +
1216 (orderByComparator.getOrderByFields().length * 6));
1217 }
1218 else {
1219 query = new StringBundler(3);
1220 }
1221
1222 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1223
1224 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1225
1226 if (orderByComparator != null) {
1227 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1228
1229 if (orderByConditionFields.length > 0) {
1230 query.append(WHERE_AND);
1231 }
1232
1233 for (int i = 0; i < orderByConditionFields.length; i++) {
1234 query.append(_ORDER_BY_ENTITY_ALIAS);
1235 query.append(orderByConditionFields[i]);
1236
1237 if ((i + 1) < orderByConditionFields.length) {
1238 if (orderByComparator.isAscending() ^ previous) {
1239 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1240 }
1241 else {
1242 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1243 }
1244 }
1245 else {
1246 if (orderByComparator.isAscending() ^ previous) {
1247 query.append(WHERE_GREATER_THAN);
1248 }
1249 else {
1250 query.append(WHERE_LESSER_THAN);
1251 }
1252 }
1253 }
1254
1255 query.append(ORDER_BY_CLAUSE);
1256
1257 String[] orderByFields = orderByComparator.getOrderByFields();
1258
1259 for (int i = 0; i < orderByFields.length; i++) {
1260 query.append(_ORDER_BY_ENTITY_ALIAS);
1261 query.append(orderByFields[i]);
1262
1263 if ((i + 1) < orderByFields.length) {
1264 if (orderByComparator.isAscending() ^ previous) {
1265 query.append(ORDER_BY_ASC_HAS_NEXT);
1266 }
1267 else {
1268 query.append(ORDER_BY_DESC_HAS_NEXT);
1269 }
1270 }
1271 else {
1272 if (orderByComparator.isAscending() ^ previous) {
1273 query.append(ORDER_BY_ASC);
1274 }
1275 else {
1276 query.append(ORDER_BY_DESC);
1277 }
1278 }
1279 }
1280 }
1281 else {
1282 query.append(JournalArticleResourceModelImpl.ORDER_BY_JPQL);
1283 }
1284
1285 String sql = query.toString();
1286
1287 Query q = session.createQuery(sql);
1288
1289 q.setFirstResult(0);
1290 q.setMaxResults(2);
1291
1292 QueryPos qPos = QueryPos.getInstance(q);
1293
1294 qPos.add(groupId);
1295
1296 if (orderByComparator != null) {
1297 Object[] values = orderByComparator.getOrderByConditionValues(journalArticleResource);
1298
1299 for (Object value : values) {
1300 qPos.add(value);
1301 }
1302 }
1303
1304 List<JournalArticleResource> list = q.list();
1305
1306 if (list.size() == 2) {
1307 return list.get(1);
1308 }
1309 else {
1310 return null;
1311 }
1312 }
1313
1314
1320 @Override
1321 public void removeByGroupId(long groupId) throws SystemException {
1322 for (JournalArticleResource journalArticleResource : findByGroupId(
1323 groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1324 remove(journalArticleResource);
1325 }
1326 }
1327
1328
1335 @Override
1336 public int countByGroupId(long groupId) throws SystemException {
1337 FinderPath finderPath = FINDER_PATH_COUNT_BY_GROUPID;
1338
1339 Object[] finderArgs = new Object[] { groupId };
1340
1341 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1342 this);
1343
1344 if (count == null) {
1345 StringBundler query = new StringBundler(2);
1346
1347 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
1348
1349 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1350
1351 String sql = query.toString();
1352
1353 Session session = null;
1354
1355 try {
1356 session = openSession();
1357
1358 Query q = session.createQuery(sql);
1359
1360 QueryPos qPos = QueryPos.getInstance(q);
1361
1362 qPos.add(groupId);
1363
1364 count = (Long)q.uniqueResult();
1365
1366 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1367 }
1368 catch (Exception e) {
1369 FinderCacheUtil.removeResult(finderPath, finderArgs);
1370
1371 throw processException(e);
1372 }
1373 finally {
1374 closeSession(session);
1375 }
1376 }
1377
1378 return count.intValue();
1379 }
1380
1381 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticleResource.groupId = ?";
1382 public static final FinderPath FINDER_PATH_FETCH_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
1383 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
1384 JournalArticleResourceImpl.class, FINDER_CLASS_NAME_ENTITY,
1385 "fetchByG_A",
1386 new String[] { Long.class.getName(), String.class.getName() },
1387 JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK |
1388 JournalArticleResourceModelImpl.ARTICLEID_COLUMN_BITMASK);
1389 public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
1390 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
1391 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_A",
1392 new String[] { Long.class.getName(), String.class.getName() });
1393
1394
1403 @Override
1404 public JournalArticleResource findByG_A(long groupId, String articleId)
1405 throws NoSuchArticleResourceException, SystemException {
1406 JournalArticleResource journalArticleResource = fetchByG_A(groupId,
1407 articleId);
1408
1409 if (journalArticleResource == null) {
1410 StringBundler msg = new StringBundler(6);
1411
1412 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1413
1414 msg.append("groupId=");
1415 msg.append(groupId);
1416
1417 msg.append(", articleId=");
1418 msg.append(articleId);
1419
1420 msg.append(StringPool.CLOSE_CURLY_BRACE);
1421
1422 if (_log.isWarnEnabled()) {
1423 _log.warn(msg.toString());
1424 }
1425
1426 throw new NoSuchArticleResourceException(msg.toString());
1427 }
1428
1429 return journalArticleResource;
1430 }
1431
1432
1440 @Override
1441 public JournalArticleResource fetchByG_A(long groupId, String articleId)
1442 throws SystemException {
1443 return fetchByG_A(groupId, articleId, true);
1444 }
1445
1446
1455 @Override
1456 public JournalArticleResource fetchByG_A(long groupId, String articleId,
1457 boolean retrieveFromCache) throws SystemException {
1458 Object[] finderArgs = new Object[] { groupId, articleId };
1459
1460 Object result = null;
1461
1462 if (retrieveFromCache) {
1463 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A,
1464 finderArgs, this);
1465 }
1466
1467 if (result instanceof JournalArticleResource) {
1468 JournalArticleResource journalArticleResource = (JournalArticleResource)result;
1469
1470 if ((groupId != journalArticleResource.getGroupId()) ||
1471 !Validator.equals(articleId,
1472 journalArticleResource.getArticleId())) {
1473 result = null;
1474 }
1475 }
1476
1477 if (result == null) {
1478 StringBundler query = new StringBundler(4);
1479
1480 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1481
1482 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1483
1484 boolean bindArticleId = false;
1485
1486 if (articleId == null) {
1487 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
1488 }
1489 else if (articleId.equals(StringPool.BLANK)) {
1490 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
1491 }
1492 else {
1493 bindArticleId = true;
1494
1495 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
1496 }
1497
1498 String sql = query.toString();
1499
1500 Session session = null;
1501
1502 try {
1503 session = openSession();
1504
1505 Query q = session.createQuery(sql);
1506
1507 QueryPos qPos = QueryPos.getInstance(q);
1508
1509 qPos.add(groupId);
1510
1511 if (bindArticleId) {
1512 qPos.add(articleId);
1513 }
1514
1515 List<JournalArticleResource> list = q.list();
1516
1517 if (list.isEmpty()) {
1518 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1519 finderArgs, list);
1520 }
1521 else {
1522 JournalArticleResource journalArticleResource = list.get(0);
1523
1524 result = journalArticleResource;
1525
1526 cacheResult(journalArticleResource);
1527
1528 if ((journalArticleResource.getGroupId() != groupId) ||
1529 (journalArticleResource.getArticleId() == null) ||
1530 !journalArticleResource.getArticleId()
1531 .equals(articleId)) {
1532 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1533 finderArgs, journalArticleResource);
1534 }
1535 }
1536 }
1537 catch (Exception e) {
1538 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
1539 finderArgs);
1540
1541 throw processException(e);
1542 }
1543 finally {
1544 closeSession(session);
1545 }
1546 }
1547
1548 if (result instanceof List<?>) {
1549 return null;
1550 }
1551 else {
1552 return (JournalArticleResource)result;
1553 }
1554 }
1555
1556
1564 @Override
1565 public JournalArticleResource removeByG_A(long groupId, String articleId)
1566 throws NoSuchArticleResourceException, SystemException {
1567 JournalArticleResource journalArticleResource = findByG_A(groupId,
1568 articleId);
1569
1570 return remove(journalArticleResource);
1571 }
1572
1573
1581 @Override
1582 public int countByG_A(long groupId, String articleId)
1583 throws SystemException {
1584 FinderPath finderPath = FINDER_PATH_COUNT_BY_G_A;
1585
1586 Object[] finderArgs = new Object[] { groupId, articleId };
1587
1588 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1589 this);
1590
1591 if (count == null) {
1592 StringBundler query = new StringBundler(3);
1593
1594 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
1595
1596 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1597
1598 boolean bindArticleId = false;
1599
1600 if (articleId == null) {
1601 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
1602 }
1603 else if (articleId.equals(StringPool.BLANK)) {
1604 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
1605 }
1606 else {
1607 bindArticleId = true;
1608
1609 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
1610 }
1611
1612 String sql = query.toString();
1613
1614 Session session = null;
1615
1616 try {
1617 session = openSession();
1618
1619 Query q = session.createQuery(sql);
1620
1621 QueryPos qPos = QueryPos.getInstance(q);
1622
1623 qPos.add(groupId);
1624
1625 if (bindArticleId) {
1626 qPos.add(articleId);
1627 }
1628
1629 count = (Long)q.uniqueResult();
1630
1631 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1632 }
1633 catch (Exception e) {
1634 FinderCacheUtil.removeResult(finderPath, finderArgs);
1635
1636 throw processException(e);
1637 }
1638 finally {
1639 closeSession(session);
1640 }
1641 }
1642
1643 return count.intValue();
1644 }
1645
1646 private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticleResource.groupId = ? AND ";
1647 private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticleResource.articleId IS NULL";
1648 private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticleResource.articleId = ?";
1649 private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticleResource.articleId IS NULL OR journalArticleResource.articleId = '')";
1650
1651
1656 @Override
1657 public void cacheResult(JournalArticleResource journalArticleResource) {
1658 EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
1659 JournalArticleResourceImpl.class,
1660 journalArticleResource.getPrimaryKey(), journalArticleResource);
1661
1662 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1663 new Object[] {
1664 journalArticleResource.getUuid(),
1665 journalArticleResource.getGroupId()
1666 }, journalArticleResource);
1667
1668 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1669 new Object[] {
1670 journalArticleResource.getGroupId(),
1671 journalArticleResource.getArticleId()
1672 }, journalArticleResource);
1673
1674 journalArticleResource.resetOriginalValues();
1675 }
1676
1677
1682 @Override
1683 public void cacheResult(
1684 List<JournalArticleResource> journalArticleResources) {
1685 for (JournalArticleResource journalArticleResource : journalArticleResources) {
1686 if (EntityCacheUtil.getResult(
1687 JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
1688 JournalArticleResourceImpl.class,
1689 journalArticleResource.getPrimaryKey()) == null) {
1690 cacheResult(journalArticleResource);
1691 }
1692 else {
1693 journalArticleResource.resetOriginalValues();
1694 }
1695 }
1696 }
1697
1698
1705 @Override
1706 public void clearCache() {
1707 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
1708 CacheRegistryUtil.clear(JournalArticleResourceImpl.class.getName());
1709 }
1710
1711 EntityCacheUtil.clearCache(JournalArticleResourceImpl.class.getName());
1712
1713 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
1714 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1715 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1716 }
1717
1718
1725 @Override
1726 public void clearCache(JournalArticleResource journalArticleResource) {
1727 EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
1728 JournalArticleResourceImpl.class,
1729 journalArticleResource.getPrimaryKey());
1730
1731 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1732 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1733
1734 clearUniqueFindersCache(journalArticleResource);
1735 }
1736
1737 @Override
1738 public void clearCache(List<JournalArticleResource> journalArticleResources) {
1739 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1740 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1741
1742 for (JournalArticleResource journalArticleResource : journalArticleResources) {
1743 EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
1744 JournalArticleResourceImpl.class,
1745 journalArticleResource.getPrimaryKey());
1746
1747 clearUniqueFindersCache(journalArticleResource);
1748 }
1749 }
1750
1751 protected void cacheUniqueFindersCache(
1752 JournalArticleResource journalArticleResource) {
1753 if (journalArticleResource.isNew()) {
1754 Object[] args = new Object[] {
1755 journalArticleResource.getUuid(),
1756 journalArticleResource.getGroupId()
1757 };
1758
1759 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
1760 Long.valueOf(1));
1761 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
1762 journalArticleResource);
1763
1764 args = new Object[] {
1765 journalArticleResource.getGroupId(),
1766 journalArticleResource.getArticleId()
1767 };
1768
1769 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, args,
1770 Long.valueOf(1));
1771 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A, args,
1772 journalArticleResource);
1773 }
1774 else {
1775 JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
1776
1777 if ((journalArticleResourceModelImpl.getColumnBitmask() &
1778 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
1779 Object[] args = new Object[] {
1780 journalArticleResource.getUuid(),
1781 journalArticleResource.getGroupId()
1782 };
1783
1784 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
1785 Long.valueOf(1));
1786 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
1787 journalArticleResource);
1788 }
1789
1790 if ((journalArticleResourceModelImpl.getColumnBitmask() &
1791 FINDER_PATH_FETCH_BY_G_A.getColumnBitmask()) != 0) {
1792 Object[] args = new Object[] {
1793 journalArticleResource.getGroupId(),
1794 journalArticleResource.getArticleId()
1795 };
1796
1797 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, args,
1798 Long.valueOf(1));
1799 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A, args,
1800 journalArticleResource);
1801 }
1802 }
1803 }
1804
1805 protected void clearUniqueFindersCache(
1806 JournalArticleResource journalArticleResource) {
1807 JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
1808
1809 Object[] args = new Object[] {
1810 journalArticleResource.getUuid(),
1811 journalArticleResource.getGroupId()
1812 };
1813
1814 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
1815 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
1816
1817 if ((journalArticleResourceModelImpl.getColumnBitmask() &
1818 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
1819 args = new Object[] {
1820 journalArticleResourceModelImpl.getOriginalUuid(),
1821 journalArticleResourceModelImpl.getOriginalGroupId()
1822 };
1823
1824 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
1825 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
1826 }
1827
1828 args = new Object[] {
1829 journalArticleResource.getGroupId(),
1830 journalArticleResource.getArticleId()
1831 };
1832
1833 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_A, args);
1834 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A, args);
1835
1836 if ((journalArticleResourceModelImpl.getColumnBitmask() &
1837 FINDER_PATH_FETCH_BY_G_A.getColumnBitmask()) != 0) {
1838 args = new Object[] {
1839 journalArticleResourceModelImpl.getOriginalGroupId(),
1840 journalArticleResourceModelImpl.getOriginalArticleId()
1841 };
1842
1843 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_A, args);
1844 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A, args);
1845 }
1846 }
1847
1848
1854 @Override
1855 public JournalArticleResource create(long resourcePrimKey) {
1856 JournalArticleResource journalArticleResource = new JournalArticleResourceImpl();
1857
1858 journalArticleResource.setNew(true);
1859 journalArticleResource.setPrimaryKey(resourcePrimKey);
1860
1861 String uuid = PortalUUIDUtil.generate();
1862
1863 journalArticleResource.setUuid(uuid);
1864
1865 return journalArticleResource;
1866 }
1867
1868
1876 @Override
1877 public JournalArticleResource remove(long resourcePrimKey)
1878 throws NoSuchArticleResourceException, SystemException {
1879 return remove((Serializable)resourcePrimKey);
1880 }
1881
1882
1890 @Override
1891 public JournalArticleResource remove(Serializable primaryKey)
1892 throws NoSuchArticleResourceException, SystemException {
1893 Session session = null;
1894
1895 try {
1896 session = openSession();
1897
1898 JournalArticleResource journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
1899 primaryKey);
1900
1901 if (journalArticleResource == null) {
1902 if (_log.isWarnEnabled()) {
1903 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
1904 }
1905
1906 throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
1907 primaryKey);
1908 }
1909
1910 return remove(journalArticleResource);
1911 }
1912 catch (NoSuchArticleResourceException nsee) {
1913 throw nsee;
1914 }
1915 catch (Exception e) {
1916 throw processException(e);
1917 }
1918 finally {
1919 closeSession(session);
1920 }
1921 }
1922
1923 @Override
1924 protected JournalArticleResource removeImpl(
1925 JournalArticleResource journalArticleResource)
1926 throws SystemException {
1927 journalArticleResource = toUnwrappedModel(journalArticleResource);
1928
1929 Session session = null;
1930
1931 try {
1932 session = openSession();
1933
1934 if (!session.contains(journalArticleResource)) {
1935 journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
1936 journalArticleResource.getPrimaryKeyObj());
1937 }
1938
1939 if (journalArticleResource != null) {
1940 session.delete(journalArticleResource);
1941 }
1942 }
1943 catch (Exception e) {
1944 throw processException(e);
1945 }
1946 finally {
1947 closeSession(session);
1948 }
1949
1950 if (journalArticleResource != null) {
1951 clearCache(journalArticleResource);
1952 }
1953
1954 return journalArticleResource;
1955 }
1956
1957 @Override
1958 public JournalArticleResource updateImpl(
1959 com.liferay.portlet.journal.model.JournalArticleResource journalArticleResource)
1960 throws SystemException {
1961 journalArticleResource = toUnwrappedModel(journalArticleResource);
1962
1963 boolean isNew = journalArticleResource.isNew();
1964
1965 JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
1966
1967 if (Validator.isNull(journalArticleResource.getUuid())) {
1968 String uuid = PortalUUIDUtil.generate();
1969
1970 journalArticleResource.setUuid(uuid);
1971 }
1972
1973 Session session = null;
1974
1975 try {
1976 session = openSession();
1977
1978 if (journalArticleResource.isNew()) {
1979 session.save(journalArticleResource);
1980
1981 journalArticleResource.setNew(false);
1982 }
1983 else {
1984 session.merge(journalArticleResource);
1985 }
1986 }
1987 catch (Exception e) {
1988 throw processException(e);
1989 }
1990 finally {
1991 closeSession(session);
1992 }
1993
1994 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1995
1996 if (isNew || !JournalArticleResourceModelImpl.COLUMN_BITMASK_ENABLED) {
1997 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1998 }
1999
2000 else {
2001 if ((journalArticleResourceModelImpl.getColumnBitmask() &
2002 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
2003 Object[] args = new Object[] {
2004 journalArticleResourceModelImpl.getOriginalUuid()
2005 };
2006
2007 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
2008 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
2009 args);
2010
2011 args = new Object[] { journalArticleResourceModelImpl.getUuid() };
2012
2013 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
2014 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
2015 args);
2016 }
2017
2018 if ((journalArticleResourceModelImpl.getColumnBitmask() &
2019 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
2020 Object[] args = new Object[] {
2021 journalArticleResourceModelImpl.getOriginalGroupId()
2022 };
2023
2024 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2025 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2026 args);
2027
2028 args = new Object[] { journalArticleResourceModelImpl.getGroupId() };
2029
2030 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2031 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2032 args);
2033 }
2034 }
2035
2036 EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
2037 JournalArticleResourceImpl.class,
2038 journalArticleResource.getPrimaryKey(), journalArticleResource);
2039
2040 clearUniqueFindersCache(journalArticleResource);
2041 cacheUniqueFindersCache(journalArticleResource);
2042
2043 return journalArticleResource;
2044 }
2045
2046 protected JournalArticleResource toUnwrappedModel(
2047 JournalArticleResource journalArticleResource) {
2048 if (journalArticleResource instanceof JournalArticleResourceImpl) {
2049 return journalArticleResource;
2050 }
2051
2052 JournalArticleResourceImpl journalArticleResourceImpl = new JournalArticleResourceImpl();
2053
2054 journalArticleResourceImpl.setNew(journalArticleResource.isNew());
2055 journalArticleResourceImpl.setPrimaryKey(journalArticleResource.getPrimaryKey());
2056
2057 journalArticleResourceImpl.setUuid(journalArticleResource.getUuid());
2058 journalArticleResourceImpl.setResourcePrimKey(journalArticleResource.getResourcePrimKey());
2059 journalArticleResourceImpl.setGroupId(journalArticleResource.getGroupId());
2060 journalArticleResourceImpl.setArticleId(journalArticleResource.getArticleId());
2061
2062 return journalArticleResourceImpl;
2063 }
2064
2065
2073 @Override
2074 public JournalArticleResource findByPrimaryKey(Serializable primaryKey)
2075 throws NoSuchArticleResourceException, SystemException {
2076 JournalArticleResource journalArticleResource = fetchByPrimaryKey(primaryKey);
2077
2078 if (journalArticleResource == null) {
2079 if (_log.isWarnEnabled()) {
2080 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2081 }
2082
2083 throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2084 primaryKey);
2085 }
2086
2087 return journalArticleResource;
2088 }
2089
2090
2098 @Override
2099 public JournalArticleResource findByPrimaryKey(long resourcePrimKey)
2100 throws NoSuchArticleResourceException, SystemException {
2101 return findByPrimaryKey((Serializable)resourcePrimKey);
2102 }
2103
2104
2111 @Override
2112 public JournalArticleResource fetchByPrimaryKey(Serializable primaryKey)
2113 throws SystemException {
2114 JournalArticleResource journalArticleResource = (JournalArticleResource)EntityCacheUtil.getResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
2115 JournalArticleResourceImpl.class, primaryKey);
2116
2117 if (journalArticleResource == _nullJournalArticleResource) {
2118 return null;
2119 }
2120
2121 if (journalArticleResource == null) {
2122 Session session = null;
2123
2124 try {
2125 session = openSession();
2126
2127 journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
2128 primaryKey);
2129
2130 if (journalArticleResource != null) {
2131 cacheResult(journalArticleResource);
2132 }
2133 else {
2134 EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
2135 JournalArticleResourceImpl.class, primaryKey,
2136 _nullJournalArticleResource);
2137 }
2138 }
2139 catch (Exception e) {
2140 EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
2141 JournalArticleResourceImpl.class, primaryKey);
2142
2143 throw processException(e);
2144 }
2145 finally {
2146 closeSession(session);
2147 }
2148 }
2149
2150 return journalArticleResource;
2151 }
2152
2153
2160 @Override
2161 public JournalArticleResource fetchByPrimaryKey(long resourcePrimKey)
2162 throws SystemException {
2163 return fetchByPrimaryKey((Serializable)resourcePrimKey);
2164 }
2165
2166
2172 @Override
2173 public List<JournalArticleResource> findAll() throws SystemException {
2174 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2175 }
2176
2177
2189 @Override
2190 public List<JournalArticleResource> findAll(int start, int end)
2191 throws SystemException {
2192 return findAll(start, end, null);
2193 }
2194
2195
2208 @Override
2209 public List<JournalArticleResource> findAll(int start, int end,
2210 OrderByComparator orderByComparator) throws SystemException {
2211 boolean pagination = true;
2212 FinderPath finderPath = null;
2213 Object[] finderArgs = null;
2214
2215 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2216 (orderByComparator == null)) {
2217 pagination = false;
2218 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
2219 finderArgs = FINDER_ARGS_EMPTY;
2220 }
2221 else {
2222 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
2223 finderArgs = new Object[] { start, end, orderByComparator };
2224 }
2225
2226 List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
2227 finderArgs, this);
2228
2229 if (list == null) {
2230 StringBundler query = null;
2231 String sql = null;
2232
2233 if (orderByComparator != null) {
2234 query = new StringBundler(2 +
2235 (orderByComparator.getOrderByFields().length * 3));
2236
2237 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE);
2238
2239 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2240 orderByComparator);
2241
2242 sql = query.toString();
2243 }
2244 else {
2245 sql = _SQL_SELECT_JOURNALARTICLERESOURCE;
2246
2247 if (pagination) {
2248 sql = sql.concat(JournalArticleResourceModelImpl.ORDER_BY_JPQL);
2249 }
2250 }
2251
2252 Session session = null;
2253
2254 try {
2255 session = openSession();
2256
2257 Query q = session.createQuery(sql);
2258
2259 if (!pagination) {
2260 list = (List<JournalArticleResource>)QueryUtil.list(q,
2261 getDialect(), start, end, false);
2262
2263 Collections.sort(list);
2264
2265 list = new UnmodifiableList<JournalArticleResource>(list);
2266 }
2267 else {
2268 list = (List<JournalArticleResource>)QueryUtil.list(q,
2269 getDialect(), start, end);
2270 }
2271
2272 cacheResult(list);
2273
2274 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2275 }
2276 catch (Exception e) {
2277 FinderCacheUtil.removeResult(finderPath, finderArgs);
2278
2279 throw processException(e);
2280 }
2281 finally {
2282 closeSession(session);
2283 }
2284 }
2285
2286 return list;
2287 }
2288
2289
2294 @Override
2295 public void removeAll() throws SystemException {
2296 for (JournalArticleResource journalArticleResource : findAll()) {
2297 remove(journalArticleResource);
2298 }
2299 }
2300
2301
2307 @Override
2308 public int countAll() throws SystemException {
2309 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2310 FINDER_ARGS_EMPTY, this);
2311
2312 if (count == null) {
2313 Session session = null;
2314
2315 try {
2316 session = openSession();
2317
2318 Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLERESOURCE);
2319
2320 count = (Long)q.uniqueResult();
2321
2322 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
2323 FINDER_ARGS_EMPTY, count);
2324 }
2325 catch (Exception e) {
2326 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
2327 FINDER_ARGS_EMPTY);
2328
2329 throw processException(e);
2330 }
2331 finally {
2332 closeSession(session);
2333 }
2334 }
2335
2336 return count.intValue();
2337 }
2338
2339 @Override
2340 protected Set<String> getBadColumnNames() {
2341 return _badColumnNames;
2342 }
2343
2344
2347 public void afterPropertiesSet() {
2348 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2349 com.liferay.portal.util.PropsUtil.get(
2350 "value.object.listener.com.liferay.portlet.journal.model.JournalArticleResource")));
2351
2352 if (listenerClassNames.length > 0) {
2353 try {
2354 List<ModelListener<JournalArticleResource>> listenersList = new ArrayList<ModelListener<JournalArticleResource>>();
2355
2356 for (String listenerClassName : listenerClassNames) {
2357 listenersList.add((ModelListener<JournalArticleResource>)InstanceFactory.newInstance(
2358 getClassLoader(), listenerClassName));
2359 }
2360
2361 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2362 }
2363 catch (Exception e) {
2364 _log.error(e);
2365 }
2366 }
2367 }
2368
2369 public void destroy() {
2370 EntityCacheUtil.removeCache(JournalArticleResourceImpl.class.getName());
2371 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2372 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2373 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2374 }
2375
2376 private static final String _SQL_SELECT_JOURNALARTICLERESOURCE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource";
2377 private static final String _SQL_SELECT_JOURNALARTICLERESOURCE_WHERE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource WHERE ";
2378 private static final String _SQL_COUNT_JOURNALARTICLERESOURCE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource";
2379 private static final String _SQL_COUNT_JOURNALARTICLERESOURCE_WHERE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource WHERE ";
2380 private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticleResource.";
2381 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticleResource exists with the primary key ";
2382 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticleResource exists with the key {";
2383 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
2384 private static Log _log = LogFactoryUtil.getLog(JournalArticleResourcePersistenceImpl.class);
2385 private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
2386 "uuid"
2387 });
2388 private static JournalArticleResource _nullJournalArticleResource = new JournalArticleResourceImpl() {
2389 @Override
2390 public Object clone() {
2391 return this;
2392 }
2393
2394 @Override
2395 public CacheModel<JournalArticleResource> toCacheModel() {
2396 return _nullJournalArticleResourceCacheModel;
2397 }
2398 };
2399
2400 private static CacheModel<JournalArticleResource> _nullJournalArticleResourceCacheModel =
2401 new CacheModel<JournalArticleResource>() {
2402 @Override
2403 public JournalArticleResource toEntityModel() {
2404 return _nullJournalArticleResource;
2405 }
2406 };
2407 }