001
014
015 package com.liferay.portlet.journal.service.persistence;
016
017 import com.liferay.portal.NoSuchModelException;
018 import com.liferay.portal.kernel.bean.BeanReference;
019 import com.liferay.portal.kernel.cache.CacheRegistryUtil;
020 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
021 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
022 import com.liferay.portal.kernel.dao.orm.FinderPath;
023 import com.liferay.portal.kernel.dao.orm.Query;
024 import com.liferay.portal.kernel.dao.orm.QueryPos;
025 import com.liferay.portal.kernel.dao.orm.QueryUtil;
026 import com.liferay.portal.kernel.dao.orm.Session;
027 import com.liferay.portal.kernel.exception.SystemException;
028 import com.liferay.portal.kernel.log.Log;
029 import com.liferay.portal.kernel.log.LogFactoryUtil;
030 import com.liferay.portal.kernel.util.GetterUtil;
031 import com.liferay.portal.kernel.util.InstanceFactory;
032 import com.liferay.portal.kernel.util.OrderByComparator;
033 import com.liferay.portal.kernel.util.StringBundler;
034 import com.liferay.portal.kernel.util.StringPool;
035 import com.liferay.portal.kernel.util.StringUtil;
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.UserPersistence;
041 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
042
043 import com.liferay.portlet.journal.NoSuchArticleResourceException;
044 import com.liferay.portlet.journal.model.JournalArticleResource;
045 import com.liferay.portlet.journal.model.impl.JournalArticleResourceImpl;
046 import com.liferay.portlet.journal.model.impl.JournalArticleResourceModelImpl;
047
048 import java.io.Serializable;
049
050 import java.util.ArrayList;
051 import java.util.Collections;
052 import java.util.List;
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_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
079 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
080 JournalArticleResourceImpl.class,
081 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
082 new String[] {
083 String.class.getName(),
084
085 "java.lang.Integer", "java.lang.Integer",
086 "com.liferay.portal.kernel.util.OrderByComparator"
087 });
088 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
089 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
090 JournalArticleResourceImpl.class,
091 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
092 new String[] { String.class.getName() },
093 JournalArticleResourceModelImpl.UUID_COLUMN_BITMASK);
094 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
095 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
096 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
097 new String[] { String.class.getName() });
098 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
099 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
100 JournalArticleResourceImpl.class, FINDER_CLASS_NAME_ENTITY,
101 "fetchByUUID_G",
102 new String[] { String.class.getName(), Long.class.getName() },
103 JournalArticleResourceModelImpl.UUID_COLUMN_BITMASK |
104 JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK);
105 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
106 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
107 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
108 new String[] { String.class.getName(), Long.class.getName() });
109 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
110 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
111 JournalArticleResourceImpl.class,
112 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
113 new String[] {
114 Long.class.getName(),
115
116 "java.lang.Integer", "java.lang.Integer",
117 "com.liferay.portal.kernel.util.OrderByComparator"
118 });
119 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
120 new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
121 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
122 JournalArticleResourceImpl.class,
123 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
124 new String[] { Long.class.getName() },
125 JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK);
126 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
127 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
128 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
129 new String[] { Long.class.getName() });
130 public static final FinderPath FINDER_PATH_FETCH_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
131 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
132 JournalArticleResourceImpl.class, FINDER_CLASS_NAME_ENTITY,
133 "fetchByG_A",
134 new String[] { Long.class.getName(), String.class.getName() },
135 JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK |
136 JournalArticleResourceModelImpl.ARTICLEID_COLUMN_BITMASK);
137 public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
138 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
139 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_A",
140 new String[] { Long.class.getName(), String.class.getName() });
141 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
142 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
143 JournalArticleResourceImpl.class,
144 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
145 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
146 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
147 JournalArticleResourceImpl.class,
148 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
149 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
150 JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
151 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
152
153
158 public void cacheResult(JournalArticleResource journalArticleResource) {
159 EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
160 JournalArticleResourceImpl.class,
161 journalArticleResource.getPrimaryKey(), journalArticleResource);
162
163 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
164 new Object[] {
165 journalArticleResource.getUuid(),
166 Long.valueOf(journalArticleResource.getGroupId())
167 }, journalArticleResource);
168
169 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
170 new Object[] {
171 Long.valueOf(journalArticleResource.getGroupId()),
172
173 journalArticleResource.getArticleId()
174 }, journalArticleResource);
175
176 journalArticleResource.resetOriginalValues();
177 }
178
179
184 public void cacheResult(
185 List<JournalArticleResource> journalArticleResources) {
186 for (JournalArticleResource journalArticleResource : journalArticleResources) {
187 if (EntityCacheUtil.getResult(
188 JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
189 JournalArticleResourceImpl.class,
190 journalArticleResource.getPrimaryKey()) == null) {
191 cacheResult(journalArticleResource);
192 }
193 else {
194 journalArticleResource.resetOriginalValues();
195 }
196 }
197 }
198
199
206 @Override
207 public void clearCache() {
208 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
209 CacheRegistryUtil.clear(JournalArticleResourceImpl.class.getName());
210 }
211
212 EntityCacheUtil.clearCache(JournalArticleResourceImpl.class.getName());
213
214 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
215 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
216 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
217 }
218
219
226 @Override
227 public void clearCache(JournalArticleResource journalArticleResource) {
228 EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
229 JournalArticleResourceImpl.class,
230 journalArticleResource.getPrimaryKey());
231
232 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
233 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
234
235 clearUniqueFindersCache(journalArticleResource);
236 }
237
238 @Override
239 public void clearCache(List<JournalArticleResource> journalArticleResources) {
240 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
241 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
242
243 for (JournalArticleResource journalArticleResource : journalArticleResources) {
244 EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
245 JournalArticleResourceImpl.class,
246 journalArticleResource.getPrimaryKey());
247
248 clearUniqueFindersCache(journalArticleResource);
249 }
250 }
251
252 protected void clearUniqueFindersCache(
253 JournalArticleResource journalArticleResource) {
254 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
255 new Object[] {
256 journalArticleResource.getUuid(),
257 Long.valueOf(journalArticleResource.getGroupId())
258 });
259
260 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
261 new Object[] {
262 Long.valueOf(journalArticleResource.getGroupId()),
263
264 journalArticleResource.getArticleId()
265 });
266 }
267
268
274 public JournalArticleResource create(long resourcePrimKey) {
275 JournalArticleResource journalArticleResource = new JournalArticleResourceImpl();
276
277 journalArticleResource.setNew(true);
278 journalArticleResource.setPrimaryKey(resourcePrimKey);
279
280 String uuid = PortalUUIDUtil.generate();
281
282 journalArticleResource.setUuid(uuid);
283
284 return journalArticleResource;
285 }
286
287
295 public JournalArticleResource remove(long resourcePrimKey)
296 throws NoSuchArticleResourceException, SystemException {
297 return remove(Long.valueOf(resourcePrimKey));
298 }
299
300
308 @Override
309 public JournalArticleResource remove(Serializable primaryKey)
310 throws NoSuchArticleResourceException, SystemException {
311 Session session = null;
312
313 try {
314 session = openSession();
315
316 JournalArticleResource journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
317 primaryKey);
318
319 if (journalArticleResource == null) {
320 if (_log.isWarnEnabled()) {
321 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
322 }
323
324 throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
325 primaryKey);
326 }
327
328 return remove(journalArticleResource);
329 }
330 catch (NoSuchArticleResourceException nsee) {
331 throw nsee;
332 }
333 catch (Exception e) {
334 throw processException(e);
335 }
336 finally {
337 closeSession(session);
338 }
339 }
340
341 @Override
342 protected JournalArticleResource removeImpl(
343 JournalArticleResource journalArticleResource)
344 throws SystemException {
345 journalArticleResource = toUnwrappedModel(journalArticleResource);
346
347 Session session = null;
348
349 try {
350 session = openSession();
351
352 if (journalArticleResource.isCachedModel()) {
353 journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
354 journalArticleResource.getPrimaryKeyObj());
355 }
356
357 session.delete(journalArticleResource);
358 }
359 catch (Exception e) {
360 throw processException(e);
361 }
362 finally {
363 closeSession(session);
364 }
365
366 clearCache(journalArticleResource);
367
368 return journalArticleResource;
369 }
370
371 @Override
372 public JournalArticleResource updateImpl(
373 com.liferay.portlet.journal.model.JournalArticleResource journalArticleResource)
374 throws SystemException {
375 journalArticleResource = toUnwrappedModel(journalArticleResource);
376
377 boolean isNew = journalArticleResource.isNew();
378
379 JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
380
381 if (Validator.isNull(journalArticleResource.getUuid())) {
382 String uuid = PortalUUIDUtil.generate();
383
384 journalArticleResource.setUuid(uuid);
385 }
386
387 Session session = null;
388
389 try {
390 session = openSession();
391
392 if (journalArticleResource.isNew()) {
393 session.save(journalArticleResource);
394
395 journalArticleResource.setNew(false);
396 }
397 else {
398 session.merge(journalArticleResource);
399 }
400 }
401 catch (Exception e) {
402 throw processException(e);
403 }
404 finally {
405 closeSession(session);
406 }
407
408 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
409
410 if (isNew || !JournalArticleResourceModelImpl.COLUMN_BITMASK_ENABLED) {
411 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
412 }
413
414 else {
415 if ((journalArticleResourceModelImpl.getColumnBitmask() &
416 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
417 Object[] args = new Object[] {
418 journalArticleResourceModelImpl.getOriginalUuid()
419 };
420
421 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
422 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
423 args);
424
425 args = new Object[] { journalArticleResourceModelImpl.getUuid() };
426
427 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
428 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
429 args);
430 }
431
432 if ((journalArticleResourceModelImpl.getColumnBitmask() &
433 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
434 Object[] args = new Object[] {
435 Long.valueOf(journalArticleResourceModelImpl.getOriginalGroupId())
436 };
437
438 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
439 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
440 args);
441
442 args = new Object[] {
443 Long.valueOf(journalArticleResourceModelImpl.getGroupId())
444 };
445
446 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
447 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
448 args);
449 }
450 }
451
452 EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
453 JournalArticleResourceImpl.class,
454 journalArticleResource.getPrimaryKey(), journalArticleResource);
455
456 if (isNew) {
457 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
458 new Object[] {
459 journalArticleResource.getUuid(),
460 Long.valueOf(journalArticleResource.getGroupId())
461 }, journalArticleResource);
462
463 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
464 new Object[] {
465 Long.valueOf(journalArticleResource.getGroupId()),
466
467 journalArticleResource.getArticleId()
468 }, journalArticleResource);
469 }
470 else {
471 if ((journalArticleResourceModelImpl.getColumnBitmask() &
472 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
473 Object[] args = new Object[] {
474 journalArticleResourceModelImpl.getOriginalUuid(),
475 Long.valueOf(journalArticleResourceModelImpl.getOriginalGroupId())
476 };
477
478 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
479
480 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
481
482 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
483 new Object[] {
484 journalArticleResource.getUuid(),
485 Long.valueOf(journalArticleResource.getGroupId())
486 }, journalArticleResource);
487 }
488
489 if ((journalArticleResourceModelImpl.getColumnBitmask() &
490 FINDER_PATH_FETCH_BY_G_A.getColumnBitmask()) != 0) {
491 Object[] args = new Object[] {
492 Long.valueOf(journalArticleResourceModelImpl.getOriginalGroupId()),
493
494 journalArticleResourceModelImpl.getOriginalArticleId()
495 };
496
497 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_A, args);
498
499 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A, args);
500
501 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
502 new Object[] {
503 Long.valueOf(journalArticleResource.getGroupId()),
504
505 journalArticleResource.getArticleId()
506 }, journalArticleResource);
507 }
508 }
509
510 return journalArticleResource;
511 }
512
513 protected JournalArticleResource toUnwrappedModel(
514 JournalArticleResource journalArticleResource) {
515 if (journalArticleResource instanceof JournalArticleResourceImpl) {
516 return journalArticleResource;
517 }
518
519 JournalArticleResourceImpl journalArticleResourceImpl = new JournalArticleResourceImpl();
520
521 journalArticleResourceImpl.setNew(journalArticleResource.isNew());
522 journalArticleResourceImpl.setPrimaryKey(journalArticleResource.getPrimaryKey());
523
524 journalArticleResourceImpl.setUuid(journalArticleResource.getUuid());
525 journalArticleResourceImpl.setResourcePrimKey(journalArticleResource.getResourcePrimKey());
526 journalArticleResourceImpl.setGroupId(journalArticleResource.getGroupId());
527 journalArticleResourceImpl.setArticleId(journalArticleResource.getArticleId());
528
529 return journalArticleResourceImpl;
530 }
531
532
540 @Override
541 public JournalArticleResource findByPrimaryKey(Serializable primaryKey)
542 throws NoSuchModelException, SystemException {
543 return findByPrimaryKey(((Long)primaryKey).longValue());
544 }
545
546
554 public JournalArticleResource findByPrimaryKey(long resourcePrimKey)
555 throws NoSuchArticleResourceException, SystemException {
556 JournalArticleResource journalArticleResource = fetchByPrimaryKey(resourcePrimKey);
557
558 if (journalArticleResource == null) {
559 if (_log.isWarnEnabled()) {
560 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + resourcePrimKey);
561 }
562
563 throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
564 resourcePrimKey);
565 }
566
567 return journalArticleResource;
568 }
569
570
577 @Override
578 public JournalArticleResource fetchByPrimaryKey(Serializable primaryKey)
579 throws SystemException {
580 return fetchByPrimaryKey(((Long)primaryKey).longValue());
581 }
582
583
590 public JournalArticleResource fetchByPrimaryKey(long resourcePrimKey)
591 throws SystemException {
592 JournalArticleResource journalArticleResource = (JournalArticleResource)EntityCacheUtil.getResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
593 JournalArticleResourceImpl.class, resourcePrimKey);
594
595 if (journalArticleResource == _nullJournalArticleResource) {
596 return null;
597 }
598
599 if (journalArticleResource == null) {
600 Session session = null;
601
602 boolean hasException = false;
603
604 try {
605 session = openSession();
606
607 journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
608 Long.valueOf(resourcePrimKey));
609 }
610 catch (Exception e) {
611 hasException = true;
612
613 throw processException(e);
614 }
615 finally {
616 if (journalArticleResource != null) {
617 cacheResult(journalArticleResource);
618 }
619 else if (!hasException) {
620 EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
621 JournalArticleResourceImpl.class, resourcePrimKey,
622 _nullJournalArticleResource);
623 }
624
625 closeSession(session);
626 }
627 }
628
629 return journalArticleResource;
630 }
631
632
639 public List<JournalArticleResource> findByUuid(String uuid)
640 throws SystemException {
641 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
642 }
643
644
657 public List<JournalArticleResource> findByUuid(String uuid, int start,
658 int end) throws SystemException {
659 return findByUuid(uuid, start, end, null);
660 }
661
662
676 public List<JournalArticleResource> findByUuid(String uuid, int start,
677 int end, OrderByComparator orderByComparator) throws SystemException {
678 FinderPath finderPath = null;
679 Object[] finderArgs = null;
680
681 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
682 (orderByComparator == null)) {
683 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
684 finderArgs = new Object[] { uuid };
685 }
686 else {
687 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
688 finderArgs = new Object[] { uuid, start, end, orderByComparator };
689 }
690
691 List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
692 finderArgs, this);
693
694 if ((list != null) && !list.isEmpty()) {
695 for (JournalArticleResource journalArticleResource : list) {
696 if (!Validator.equals(uuid, journalArticleResource.getUuid())) {
697 list = null;
698
699 break;
700 }
701 }
702 }
703
704 if (list == null) {
705 StringBundler query = null;
706
707 if (orderByComparator != null) {
708 query = new StringBundler(3 +
709 (orderByComparator.getOrderByFields().length * 3));
710 }
711 else {
712 query = new StringBundler(2);
713 }
714
715 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
716
717 if (uuid == null) {
718 query.append(_FINDER_COLUMN_UUID_UUID_1);
719 }
720 else {
721 if (uuid.equals(StringPool.BLANK)) {
722 query.append(_FINDER_COLUMN_UUID_UUID_3);
723 }
724 else {
725 query.append(_FINDER_COLUMN_UUID_UUID_2);
726 }
727 }
728
729 if (orderByComparator != null) {
730 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
731 orderByComparator);
732 }
733
734 String sql = query.toString();
735
736 Session session = null;
737
738 try {
739 session = openSession();
740
741 Query q = session.createQuery(sql);
742
743 QueryPos qPos = QueryPos.getInstance(q);
744
745 if (uuid != null) {
746 qPos.add(uuid);
747 }
748
749 list = (List<JournalArticleResource>)QueryUtil.list(q,
750 getDialect(), start, end);
751 }
752 catch (Exception e) {
753 throw processException(e);
754 }
755 finally {
756 if (list == null) {
757 FinderCacheUtil.removeResult(finderPath, finderArgs);
758 }
759 else {
760 cacheResult(list);
761
762 FinderCacheUtil.putResult(finderPath, finderArgs, list);
763 }
764
765 closeSession(session);
766 }
767 }
768
769 return list;
770 }
771
772
781 public JournalArticleResource findByUuid_First(String uuid,
782 OrderByComparator orderByComparator)
783 throws NoSuchArticleResourceException, SystemException {
784 JournalArticleResource journalArticleResource = fetchByUuid_First(uuid,
785 orderByComparator);
786
787 if (journalArticleResource != null) {
788 return journalArticleResource;
789 }
790
791 StringBundler msg = new StringBundler(4);
792
793 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
794
795 msg.append("uuid=");
796 msg.append(uuid);
797
798 msg.append(StringPool.CLOSE_CURLY_BRACE);
799
800 throw new NoSuchArticleResourceException(msg.toString());
801 }
802
803
811 public JournalArticleResource fetchByUuid_First(String uuid,
812 OrderByComparator orderByComparator) throws SystemException {
813 List<JournalArticleResource> list = findByUuid(uuid, 0, 1,
814 orderByComparator);
815
816 if (!list.isEmpty()) {
817 return list.get(0);
818 }
819
820 return null;
821 }
822
823
832 public JournalArticleResource findByUuid_Last(String uuid,
833 OrderByComparator orderByComparator)
834 throws NoSuchArticleResourceException, SystemException {
835 JournalArticleResource journalArticleResource = fetchByUuid_Last(uuid,
836 orderByComparator);
837
838 if (journalArticleResource != null) {
839 return journalArticleResource;
840 }
841
842 StringBundler msg = new StringBundler(4);
843
844 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
845
846 msg.append("uuid=");
847 msg.append(uuid);
848
849 msg.append(StringPool.CLOSE_CURLY_BRACE);
850
851 throw new NoSuchArticleResourceException(msg.toString());
852 }
853
854
862 public JournalArticleResource fetchByUuid_Last(String uuid,
863 OrderByComparator orderByComparator) throws SystemException {
864 int count = countByUuid(uuid);
865
866 List<JournalArticleResource> list = findByUuid(uuid, count - 1, count,
867 orderByComparator);
868
869 if (!list.isEmpty()) {
870 return list.get(0);
871 }
872
873 return null;
874 }
875
876
886 public JournalArticleResource[] findByUuid_PrevAndNext(
887 long resourcePrimKey, String uuid, OrderByComparator orderByComparator)
888 throws NoSuchArticleResourceException, SystemException {
889 JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
890
891 Session session = null;
892
893 try {
894 session = openSession();
895
896 JournalArticleResource[] array = new JournalArticleResourceImpl[3];
897
898 array[0] = getByUuid_PrevAndNext(session, journalArticleResource,
899 uuid, orderByComparator, true);
900
901 array[1] = journalArticleResource;
902
903 array[2] = getByUuid_PrevAndNext(session, journalArticleResource,
904 uuid, orderByComparator, false);
905
906 return array;
907 }
908 catch (Exception e) {
909 throw processException(e);
910 }
911 finally {
912 closeSession(session);
913 }
914 }
915
916 protected JournalArticleResource getByUuid_PrevAndNext(Session session,
917 JournalArticleResource journalArticleResource, String uuid,
918 OrderByComparator orderByComparator, boolean previous) {
919 StringBundler query = null;
920
921 if (orderByComparator != null) {
922 query = new StringBundler(6 +
923 (orderByComparator.getOrderByFields().length * 6));
924 }
925 else {
926 query = new StringBundler(3);
927 }
928
929 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
930
931 if (uuid == null) {
932 query.append(_FINDER_COLUMN_UUID_UUID_1);
933 }
934 else {
935 if (uuid.equals(StringPool.BLANK)) {
936 query.append(_FINDER_COLUMN_UUID_UUID_3);
937 }
938 else {
939 query.append(_FINDER_COLUMN_UUID_UUID_2);
940 }
941 }
942
943 if (orderByComparator != null) {
944 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
945
946 if (orderByConditionFields.length > 0) {
947 query.append(WHERE_AND);
948 }
949
950 for (int i = 0; i < orderByConditionFields.length; i++) {
951 query.append(_ORDER_BY_ENTITY_ALIAS);
952 query.append(orderByConditionFields[i]);
953
954 if ((i + 1) < orderByConditionFields.length) {
955 if (orderByComparator.isAscending() ^ previous) {
956 query.append(WHERE_GREATER_THAN_HAS_NEXT);
957 }
958 else {
959 query.append(WHERE_LESSER_THAN_HAS_NEXT);
960 }
961 }
962 else {
963 if (orderByComparator.isAscending() ^ previous) {
964 query.append(WHERE_GREATER_THAN);
965 }
966 else {
967 query.append(WHERE_LESSER_THAN);
968 }
969 }
970 }
971
972 query.append(ORDER_BY_CLAUSE);
973
974 String[] orderByFields = orderByComparator.getOrderByFields();
975
976 for (int i = 0; i < orderByFields.length; i++) {
977 query.append(_ORDER_BY_ENTITY_ALIAS);
978 query.append(orderByFields[i]);
979
980 if ((i + 1) < orderByFields.length) {
981 if (orderByComparator.isAscending() ^ previous) {
982 query.append(ORDER_BY_ASC_HAS_NEXT);
983 }
984 else {
985 query.append(ORDER_BY_DESC_HAS_NEXT);
986 }
987 }
988 else {
989 if (orderByComparator.isAscending() ^ previous) {
990 query.append(ORDER_BY_ASC);
991 }
992 else {
993 query.append(ORDER_BY_DESC);
994 }
995 }
996 }
997 }
998
999 String sql = query.toString();
1000
1001 Query q = session.createQuery(sql);
1002
1003 q.setFirstResult(0);
1004 q.setMaxResults(2);
1005
1006 QueryPos qPos = QueryPos.getInstance(q);
1007
1008 if (uuid != null) {
1009 qPos.add(uuid);
1010 }
1011
1012 if (orderByComparator != null) {
1013 Object[] values = orderByComparator.getOrderByConditionValues(journalArticleResource);
1014
1015 for (Object value : values) {
1016 qPos.add(value);
1017 }
1018 }
1019
1020 List<JournalArticleResource> list = q.list();
1021
1022 if (list.size() == 2) {
1023 return list.get(1);
1024 }
1025 else {
1026 return null;
1027 }
1028 }
1029
1030
1039 public JournalArticleResource findByUUID_G(String uuid, long groupId)
1040 throws NoSuchArticleResourceException, SystemException {
1041 JournalArticleResource journalArticleResource = fetchByUUID_G(uuid,
1042 groupId);
1043
1044 if (journalArticleResource == null) {
1045 StringBundler msg = new StringBundler(6);
1046
1047 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1048
1049 msg.append("uuid=");
1050 msg.append(uuid);
1051
1052 msg.append(", groupId=");
1053 msg.append(groupId);
1054
1055 msg.append(StringPool.CLOSE_CURLY_BRACE);
1056
1057 if (_log.isWarnEnabled()) {
1058 _log.warn(msg.toString());
1059 }
1060
1061 throw new NoSuchArticleResourceException(msg.toString());
1062 }
1063
1064 return journalArticleResource;
1065 }
1066
1067
1075 public JournalArticleResource fetchByUUID_G(String uuid, long groupId)
1076 throws SystemException {
1077 return fetchByUUID_G(uuid, groupId, true);
1078 }
1079
1080
1089 public JournalArticleResource fetchByUUID_G(String uuid, long groupId,
1090 boolean retrieveFromCache) throws SystemException {
1091 Object[] finderArgs = new Object[] { uuid, groupId };
1092
1093 Object result = null;
1094
1095 if (retrieveFromCache) {
1096 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
1097 finderArgs, this);
1098 }
1099
1100 if (result instanceof JournalArticleResource) {
1101 JournalArticleResource journalArticleResource = (JournalArticleResource)result;
1102
1103 if (!Validator.equals(uuid, journalArticleResource.getUuid()) ||
1104 (groupId != journalArticleResource.getGroupId())) {
1105 result = null;
1106 }
1107 }
1108
1109 if (result == null) {
1110 StringBundler query = new StringBundler(3);
1111
1112 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1113
1114 if (uuid == null) {
1115 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1116 }
1117 else {
1118 if (uuid.equals(StringPool.BLANK)) {
1119 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1120 }
1121 else {
1122 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1123 }
1124 }
1125
1126 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1127
1128 String sql = query.toString();
1129
1130 Session session = null;
1131
1132 try {
1133 session = openSession();
1134
1135 Query q = session.createQuery(sql);
1136
1137 QueryPos qPos = QueryPos.getInstance(q);
1138
1139 if (uuid != null) {
1140 qPos.add(uuid);
1141 }
1142
1143 qPos.add(groupId);
1144
1145 List<JournalArticleResource> list = q.list();
1146
1147 result = list;
1148
1149 JournalArticleResource journalArticleResource = null;
1150
1151 if (list.isEmpty()) {
1152 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1153 finderArgs, list);
1154 }
1155 else {
1156 journalArticleResource = list.get(0);
1157
1158 cacheResult(journalArticleResource);
1159
1160 if ((journalArticleResource.getUuid() == null) ||
1161 !journalArticleResource.getUuid().equals(uuid) ||
1162 (journalArticleResource.getGroupId() != groupId)) {
1163 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1164 finderArgs, journalArticleResource);
1165 }
1166 }
1167
1168 return journalArticleResource;
1169 }
1170 catch (Exception e) {
1171 throw processException(e);
1172 }
1173 finally {
1174 if (result == null) {
1175 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
1176 finderArgs);
1177 }
1178
1179 closeSession(session);
1180 }
1181 }
1182 else {
1183 if (result instanceof List<?>) {
1184 return null;
1185 }
1186 else {
1187 return (JournalArticleResource)result;
1188 }
1189 }
1190 }
1191
1192
1199 public List<JournalArticleResource> findByGroupId(long groupId)
1200 throws SystemException {
1201 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1202 }
1203
1204
1217 public List<JournalArticleResource> findByGroupId(long groupId, int start,
1218 int end) throws SystemException {
1219 return findByGroupId(groupId, start, end, null);
1220 }
1221
1222
1236 public List<JournalArticleResource> findByGroupId(long groupId, int start,
1237 int end, OrderByComparator orderByComparator) throws SystemException {
1238 FinderPath finderPath = null;
1239 Object[] finderArgs = null;
1240
1241 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1242 (orderByComparator == null)) {
1243 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
1244 finderArgs = new Object[] { groupId };
1245 }
1246 else {
1247 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
1248 finderArgs = new Object[] { groupId, start, end, orderByComparator };
1249 }
1250
1251 List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
1252 finderArgs, this);
1253
1254 if ((list != null) && !list.isEmpty()) {
1255 for (JournalArticleResource journalArticleResource : list) {
1256 if ((groupId != journalArticleResource.getGroupId())) {
1257 list = null;
1258
1259 break;
1260 }
1261 }
1262 }
1263
1264 if (list == null) {
1265 StringBundler query = null;
1266
1267 if (orderByComparator != null) {
1268 query = new StringBundler(3 +
1269 (orderByComparator.getOrderByFields().length * 3));
1270 }
1271 else {
1272 query = new StringBundler(2);
1273 }
1274
1275 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1276
1277 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1278
1279 if (orderByComparator != null) {
1280 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1281 orderByComparator);
1282 }
1283
1284 String sql = query.toString();
1285
1286 Session session = null;
1287
1288 try {
1289 session = openSession();
1290
1291 Query q = session.createQuery(sql);
1292
1293 QueryPos qPos = QueryPos.getInstance(q);
1294
1295 qPos.add(groupId);
1296
1297 list = (List<JournalArticleResource>)QueryUtil.list(q,
1298 getDialect(), start, end);
1299 }
1300 catch (Exception e) {
1301 throw processException(e);
1302 }
1303 finally {
1304 if (list == null) {
1305 FinderCacheUtil.removeResult(finderPath, finderArgs);
1306 }
1307 else {
1308 cacheResult(list);
1309
1310 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1311 }
1312
1313 closeSession(session);
1314 }
1315 }
1316
1317 return list;
1318 }
1319
1320
1329 public JournalArticleResource findByGroupId_First(long groupId,
1330 OrderByComparator orderByComparator)
1331 throws NoSuchArticleResourceException, SystemException {
1332 JournalArticleResource journalArticleResource = fetchByGroupId_First(groupId,
1333 orderByComparator);
1334
1335 if (journalArticleResource != null) {
1336 return journalArticleResource;
1337 }
1338
1339 StringBundler msg = new StringBundler(4);
1340
1341 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1342
1343 msg.append("groupId=");
1344 msg.append(groupId);
1345
1346 msg.append(StringPool.CLOSE_CURLY_BRACE);
1347
1348 throw new NoSuchArticleResourceException(msg.toString());
1349 }
1350
1351
1359 public JournalArticleResource fetchByGroupId_First(long groupId,
1360 OrderByComparator orderByComparator) throws SystemException {
1361 List<JournalArticleResource> list = findByGroupId(groupId, 0, 1,
1362 orderByComparator);
1363
1364 if (!list.isEmpty()) {
1365 return list.get(0);
1366 }
1367
1368 return null;
1369 }
1370
1371
1380 public JournalArticleResource findByGroupId_Last(long groupId,
1381 OrderByComparator orderByComparator)
1382 throws NoSuchArticleResourceException, SystemException {
1383 JournalArticleResource journalArticleResource = fetchByGroupId_Last(groupId,
1384 orderByComparator);
1385
1386 if (journalArticleResource != null) {
1387 return journalArticleResource;
1388 }
1389
1390 StringBundler msg = new StringBundler(4);
1391
1392 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1393
1394 msg.append("groupId=");
1395 msg.append(groupId);
1396
1397 msg.append(StringPool.CLOSE_CURLY_BRACE);
1398
1399 throw new NoSuchArticleResourceException(msg.toString());
1400 }
1401
1402
1410 public JournalArticleResource fetchByGroupId_Last(long groupId,
1411 OrderByComparator orderByComparator) throws SystemException {
1412 int count = countByGroupId(groupId);
1413
1414 List<JournalArticleResource> list = findByGroupId(groupId, count - 1,
1415 count, orderByComparator);
1416
1417 if (!list.isEmpty()) {
1418 return list.get(0);
1419 }
1420
1421 return null;
1422 }
1423
1424
1434 public JournalArticleResource[] findByGroupId_PrevAndNext(
1435 long resourcePrimKey, long groupId, OrderByComparator orderByComparator)
1436 throws NoSuchArticleResourceException, SystemException {
1437 JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
1438
1439 Session session = null;
1440
1441 try {
1442 session = openSession();
1443
1444 JournalArticleResource[] array = new JournalArticleResourceImpl[3];
1445
1446 array[0] = getByGroupId_PrevAndNext(session,
1447 journalArticleResource, groupId, orderByComparator, true);
1448
1449 array[1] = journalArticleResource;
1450
1451 array[2] = getByGroupId_PrevAndNext(session,
1452 journalArticleResource, groupId, orderByComparator, false);
1453
1454 return array;
1455 }
1456 catch (Exception e) {
1457 throw processException(e);
1458 }
1459 finally {
1460 closeSession(session);
1461 }
1462 }
1463
1464 protected JournalArticleResource getByGroupId_PrevAndNext(Session session,
1465 JournalArticleResource journalArticleResource, long groupId,
1466 OrderByComparator orderByComparator, boolean previous) {
1467 StringBundler query = null;
1468
1469 if (orderByComparator != null) {
1470 query = new StringBundler(6 +
1471 (orderByComparator.getOrderByFields().length * 6));
1472 }
1473 else {
1474 query = new StringBundler(3);
1475 }
1476
1477 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1478
1479 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1480
1481 if (orderByComparator != null) {
1482 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1483
1484 if (orderByConditionFields.length > 0) {
1485 query.append(WHERE_AND);
1486 }
1487
1488 for (int i = 0; i < orderByConditionFields.length; i++) {
1489 query.append(_ORDER_BY_ENTITY_ALIAS);
1490 query.append(orderByConditionFields[i]);
1491
1492 if ((i + 1) < orderByConditionFields.length) {
1493 if (orderByComparator.isAscending() ^ previous) {
1494 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1495 }
1496 else {
1497 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1498 }
1499 }
1500 else {
1501 if (orderByComparator.isAscending() ^ previous) {
1502 query.append(WHERE_GREATER_THAN);
1503 }
1504 else {
1505 query.append(WHERE_LESSER_THAN);
1506 }
1507 }
1508 }
1509
1510 query.append(ORDER_BY_CLAUSE);
1511
1512 String[] orderByFields = orderByComparator.getOrderByFields();
1513
1514 for (int i = 0; i < orderByFields.length; i++) {
1515 query.append(_ORDER_BY_ENTITY_ALIAS);
1516 query.append(orderByFields[i]);
1517
1518 if ((i + 1) < orderByFields.length) {
1519 if (orderByComparator.isAscending() ^ previous) {
1520 query.append(ORDER_BY_ASC_HAS_NEXT);
1521 }
1522 else {
1523 query.append(ORDER_BY_DESC_HAS_NEXT);
1524 }
1525 }
1526 else {
1527 if (orderByComparator.isAscending() ^ previous) {
1528 query.append(ORDER_BY_ASC);
1529 }
1530 else {
1531 query.append(ORDER_BY_DESC);
1532 }
1533 }
1534 }
1535 }
1536
1537 String sql = query.toString();
1538
1539 Query q = session.createQuery(sql);
1540
1541 q.setFirstResult(0);
1542 q.setMaxResults(2);
1543
1544 QueryPos qPos = QueryPos.getInstance(q);
1545
1546 qPos.add(groupId);
1547
1548 if (orderByComparator != null) {
1549 Object[] values = orderByComparator.getOrderByConditionValues(journalArticleResource);
1550
1551 for (Object value : values) {
1552 qPos.add(value);
1553 }
1554 }
1555
1556 List<JournalArticleResource> list = q.list();
1557
1558 if (list.size() == 2) {
1559 return list.get(1);
1560 }
1561 else {
1562 return null;
1563 }
1564 }
1565
1566
1575 public JournalArticleResource findByG_A(long groupId, String articleId)
1576 throws NoSuchArticleResourceException, SystemException {
1577 JournalArticleResource journalArticleResource = fetchByG_A(groupId,
1578 articleId);
1579
1580 if (journalArticleResource == null) {
1581 StringBundler msg = new StringBundler(6);
1582
1583 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1584
1585 msg.append("groupId=");
1586 msg.append(groupId);
1587
1588 msg.append(", articleId=");
1589 msg.append(articleId);
1590
1591 msg.append(StringPool.CLOSE_CURLY_BRACE);
1592
1593 if (_log.isWarnEnabled()) {
1594 _log.warn(msg.toString());
1595 }
1596
1597 throw new NoSuchArticleResourceException(msg.toString());
1598 }
1599
1600 return journalArticleResource;
1601 }
1602
1603
1611 public JournalArticleResource fetchByG_A(long groupId, String articleId)
1612 throws SystemException {
1613 return fetchByG_A(groupId, articleId, true);
1614 }
1615
1616
1625 public JournalArticleResource fetchByG_A(long groupId, String articleId,
1626 boolean retrieveFromCache) throws SystemException {
1627 Object[] finderArgs = new Object[] { groupId, articleId };
1628
1629 Object result = null;
1630
1631 if (retrieveFromCache) {
1632 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A,
1633 finderArgs, this);
1634 }
1635
1636 if (result instanceof JournalArticleResource) {
1637 JournalArticleResource journalArticleResource = (JournalArticleResource)result;
1638
1639 if ((groupId != journalArticleResource.getGroupId()) ||
1640 !Validator.equals(articleId,
1641 journalArticleResource.getArticleId())) {
1642 result = null;
1643 }
1644 }
1645
1646 if (result == null) {
1647 StringBundler query = new StringBundler(3);
1648
1649 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1650
1651 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1652
1653 if (articleId == null) {
1654 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
1655 }
1656 else {
1657 if (articleId.equals(StringPool.BLANK)) {
1658 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
1659 }
1660 else {
1661 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
1662 }
1663 }
1664
1665 String sql = query.toString();
1666
1667 Session session = null;
1668
1669 try {
1670 session = openSession();
1671
1672 Query q = session.createQuery(sql);
1673
1674 QueryPos qPos = QueryPos.getInstance(q);
1675
1676 qPos.add(groupId);
1677
1678 if (articleId != null) {
1679 qPos.add(articleId);
1680 }
1681
1682 List<JournalArticleResource> list = q.list();
1683
1684 result = list;
1685
1686 JournalArticleResource journalArticleResource = null;
1687
1688 if (list.isEmpty()) {
1689 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1690 finderArgs, list);
1691 }
1692 else {
1693 journalArticleResource = list.get(0);
1694
1695 cacheResult(journalArticleResource);
1696
1697 if ((journalArticleResource.getGroupId() != groupId) ||
1698 (journalArticleResource.getArticleId() == null) ||
1699 !journalArticleResource.getArticleId()
1700 .equals(articleId)) {
1701 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1702 finderArgs, journalArticleResource);
1703 }
1704 }
1705
1706 return journalArticleResource;
1707 }
1708 catch (Exception e) {
1709 throw processException(e);
1710 }
1711 finally {
1712 if (result == null) {
1713 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
1714 finderArgs);
1715 }
1716
1717 closeSession(session);
1718 }
1719 }
1720 else {
1721 if (result instanceof List<?>) {
1722 return null;
1723 }
1724 else {
1725 return (JournalArticleResource)result;
1726 }
1727 }
1728 }
1729
1730
1736 public List<JournalArticleResource> findAll() throws SystemException {
1737 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1738 }
1739
1740
1752 public List<JournalArticleResource> findAll(int start, int end)
1753 throws SystemException {
1754 return findAll(start, end, null);
1755 }
1756
1757
1770 public List<JournalArticleResource> findAll(int start, int end,
1771 OrderByComparator orderByComparator) throws SystemException {
1772 FinderPath finderPath = null;
1773 Object[] finderArgs = new Object[] { start, end, orderByComparator };
1774
1775 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1776 (orderByComparator == null)) {
1777 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
1778 finderArgs = FINDER_ARGS_EMPTY;
1779 }
1780 else {
1781 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
1782 finderArgs = new Object[] { start, end, orderByComparator };
1783 }
1784
1785 List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
1786 finderArgs, this);
1787
1788 if (list == null) {
1789 StringBundler query = null;
1790 String sql = null;
1791
1792 if (orderByComparator != null) {
1793 query = new StringBundler(2 +
1794 (orderByComparator.getOrderByFields().length * 3));
1795
1796 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE);
1797
1798 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1799 orderByComparator);
1800
1801 sql = query.toString();
1802 }
1803 else {
1804 sql = _SQL_SELECT_JOURNALARTICLERESOURCE;
1805 }
1806
1807 Session session = null;
1808
1809 try {
1810 session = openSession();
1811
1812 Query q = session.createQuery(sql);
1813
1814 if (orderByComparator == null) {
1815 list = (List<JournalArticleResource>)QueryUtil.list(q,
1816 getDialect(), start, end, false);
1817
1818 Collections.sort(list);
1819 }
1820 else {
1821 list = (List<JournalArticleResource>)QueryUtil.list(q,
1822 getDialect(), start, end);
1823 }
1824 }
1825 catch (Exception e) {
1826 throw processException(e);
1827 }
1828 finally {
1829 if (list == null) {
1830 FinderCacheUtil.removeResult(finderPath, finderArgs);
1831 }
1832 else {
1833 cacheResult(list);
1834
1835 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1836 }
1837
1838 closeSession(session);
1839 }
1840 }
1841
1842 return list;
1843 }
1844
1845
1851 public void removeByUuid(String uuid) throws SystemException {
1852 for (JournalArticleResource journalArticleResource : findByUuid(uuid)) {
1853 remove(journalArticleResource);
1854 }
1855 }
1856
1857
1865 public JournalArticleResource removeByUUID_G(String uuid, long groupId)
1866 throws NoSuchArticleResourceException, SystemException {
1867 JournalArticleResource journalArticleResource = findByUUID_G(uuid,
1868 groupId);
1869
1870 return remove(journalArticleResource);
1871 }
1872
1873
1879 public void removeByGroupId(long groupId) throws SystemException {
1880 for (JournalArticleResource journalArticleResource : findByGroupId(
1881 groupId)) {
1882 remove(journalArticleResource);
1883 }
1884 }
1885
1886
1894 public JournalArticleResource removeByG_A(long groupId, String articleId)
1895 throws NoSuchArticleResourceException, SystemException {
1896 JournalArticleResource journalArticleResource = findByG_A(groupId,
1897 articleId);
1898
1899 return remove(journalArticleResource);
1900 }
1901
1902
1907 public void removeAll() throws SystemException {
1908 for (JournalArticleResource journalArticleResource : findAll()) {
1909 remove(journalArticleResource);
1910 }
1911 }
1912
1913
1920 public int countByUuid(String uuid) throws SystemException {
1921 Object[] finderArgs = new Object[] { uuid };
1922
1923 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
1924 finderArgs, this);
1925
1926 if (count == null) {
1927 StringBundler query = new StringBundler(2);
1928
1929 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
1930
1931 if (uuid == null) {
1932 query.append(_FINDER_COLUMN_UUID_UUID_1);
1933 }
1934 else {
1935 if (uuid.equals(StringPool.BLANK)) {
1936 query.append(_FINDER_COLUMN_UUID_UUID_3);
1937 }
1938 else {
1939 query.append(_FINDER_COLUMN_UUID_UUID_2);
1940 }
1941 }
1942
1943 String sql = query.toString();
1944
1945 Session session = null;
1946
1947 try {
1948 session = openSession();
1949
1950 Query q = session.createQuery(sql);
1951
1952 QueryPos qPos = QueryPos.getInstance(q);
1953
1954 if (uuid != null) {
1955 qPos.add(uuid);
1956 }
1957
1958 count = (Long)q.uniqueResult();
1959 }
1960 catch (Exception e) {
1961 throw processException(e);
1962 }
1963 finally {
1964 if (count == null) {
1965 count = Long.valueOf(0);
1966 }
1967
1968 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
1969 finderArgs, count);
1970
1971 closeSession(session);
1972 }
1973 }
1974
1975 return count.intValue();
1976 }
1977
1978
1986 public int countByUUID_G(String uuid, long groupId)
1987 throws SystemException {
1988 Object[] finderArgs = new Object[] { uuid, groupId };
1989
1990 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
1991 finderArgs, this);
1992
1993 if (count == null) {
1994 StringBundler query = new StringBundler(3);
1995
1996 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
1997
1998 if (uuid == null) {
1999 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
2000 }
2001 else {
2002 if (uuid.equals(StringPool.BLANK)) {
2003 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
2004 }
2005 else {
2006 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
2007 }
2008 }
2009
2010 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
2011
2012 String sql = query.toString();
2013
2014 Session session = null;
2015
2016 try {
2017 session = openSession();
2018
2019 Query q = session.createQuery(sql);
2020
2021 QueryPos qPos = QueryPos.getInstance(q);
2022
2023 if (uuid != null) {
2024 qPos.add(uuid);
2025 }
2026
2027 qPos.add(groupId);
2028
2029 count = (Long)q.uniqueResult();
2030 }
2031 catch (Exception e) {
2032 throw processException(e);
2033 }
2034 finally {
2035 if (count == null) {
2036 count = Long.valueOf(0);
2037 }
2038
2039 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
2040 finderArgs, count);
2041
2042 closeSession(session);
2043 }
2044 }
2045
2046 return count.intValue();
2047 }
2048
2049
2056 public int countByGroupId(long groupId) throws SystemException {
2057 Object[] finderArgs = new Object[] { groupId };
2058
2059 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
2060 finderArgs, this);
2061
2062 if (count == null) {
2063 StringBundler query = new StringBundler(2);
2064
2065 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
2066
2067 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2068
2069 String sql = query.toString();
2070
2071 Session session = null;
2072
2073 try {
2074 session = openSession();
2075
2076 Query q = session.createQuery(sql);
2077
2078 QueryPos qPos = QueryPos.getInstance(q);
2079
2080 qPos.add(groupId);
2081
2082 count = (Long)q.uniqueResult();
2083 }
2084 catch (Exception e) {
2085 throw processException(e);
2086 }
2087 finally {
2088 if (count == null) {
2089 count = Long.valueOf(0);
2090 }
2091
2092 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
2093 finderArgs, count);
2094
2095 closeSession(session);
2096 }
2097 }
2098
2099 return count.intValue();
2100 }
2101
2102
2110 public int countByG_A(long groupId, String articleId)
2111 throws SystemException {
2112 Object[] finderArgs = new Object[] { groupId, articleId };
2113
2114 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
2115 finderArgs, this);
2116
2117 if (count == null) {
2118 StringBundler query = new StringBundler(3);
2119
2120 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
2121
2122 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2123
2124 if (articleId == null) {
2125 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2126 }
2127 else {
2128 if (articleId.equals(StringPool.BLANK)) {
2129 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2130 }
2131 else {
2132 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2133 }
2134 }
2135
2136 String sql = query.toString();
2137
2138 Session session = null;
2139
2140 try {
2141 session = openSession();
2142
2143 Query q = session.createQuery(sql);
2144
2145 QueryPos qPos = QueryPos.getInstance(q);
2146
2147 qPos.add(groupId);
2148
2149 if (articleId != null) {
2150 qPos.add(articleId);
2151 }
2152
2153 count = (Long)q.uniqueResult();
2154 }
2155 catch (Exception e) {
2156 throw processException(e);
2157 }
2158 finally {
2159 if (count == null) {
2160 count = Long.valueOf(0);
2161 }
2162
2163 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
2164 count);
2165
2166 closeSession(session);
2167 }
2168 }
2169
2170 return count.intValue();
2171 }
2172
2173
2179 public int countAll() throws SystemException {
2180 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2181 FINDER_ARGS_EMPTY, this);
2182
2183 if (count == null) {
2184 Session session = null;
2185
2186 try {
2187 session = openSession();
2188
2189 Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLERESOURCE);
2190
2191 count = (Long)q.uniqueResult();
2192 }
2193 catch (Exception e) {
2194 throw processException(e);
2195 }
2196 finally {
2197 if (count == null) {
2198 count = Long.valueOf(0);
2199 }
2200
2201 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
2202 FINDER_ARGS_EMPTY, count);
2203
2204 closeSession(session);
2205 }
2206 }
2207
2208 return count.intValue();
2209 }
2210
2211
2214 public void afterPropertiesSet() {
2215 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2216 com.liferay.portal.util.PropsUtil.get(
2217 "value.object.listener.com.liferay.portlet.journal.model.JournalArticleResource")));
2218
2219 if (listenerClassNames.length > 0) {
2220 try {
2221 List<ModelListener<JournalArticleResource>> listenersList = new ArrayList<ModelListener<JournalArticleResource>>();
2222
2223 for (String listenerClassName : listenerClassNames) {
2224 listenersList.add((ModelListener<JournalArticleResource>)InstanceFactory.newInstance(
2225 listenerClassName));
2226 }
2227
2228 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2229 }
2230 catch (Exception e) {
2231 _log.error(e);
2232 }
2233 }
2234 }
2235
2236 public void destroy() {
2237 EntityCacheUtil.removeCache(JournalArticleResourceImpl.class.getName());
2238 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2239 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2240 }
2241
2242 @BeanReference(type = JournalArticlePersistence.class)
2243 protected JournalArticlePersistence journalArticlePersistence;
2244 @BeanReference(type = JournalArticleImagePersistence.class)
2245 protected JournalArticleImagePersistence journalArticleImagePersistence;
2246 @BeanReference(type = JournalArticleResourcePersistence.class)
2247 protected JournalArticleResourcePersistence journalArticleResourcePersistence;
2248 @BeanReference(type = JournalContentSearchPersistence.class)
2249 protected JournalContentSearchPersistence journalContentSearchPersistence;
2250 @BeanReference(type = JournalFeedPersistence.class)
2251 protected JournalFeedPersistence journalFeedPersistence;
2252 @BeanReference(type = JournalFolderPersistence.class)
2253 protected JournalFolderPersistence journalFolderPersistence;
2254 @BeanReference(type = JournalStructurePersistence.class)
2255 protected JournalStructurePersistence journalStructurePersistence;
2256 @BeanReference(type = JournalTemplatePersistence.class)
2257 protected JournalTemplatePersistence journalTemplatePersistence;
2258 @BeanReference(type = UserPersistence.class)
2259 protected UserPersistence userPersistence;
2260 private static final String _SQL_SELECT_JOURNALARTICLERESOURCE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource";
2261 private static final String _SQL_SELECT_JOURNALARTICLERESOURCE_WHERE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource WHERE ";
2262 private static final String _SQL_COUNT_JOURNALARTICLERESOURCE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource";
2263 private static final String _SQL_COUNT_JOURNALARTICLERESOURCE_WHERE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource WHERE ";
2264 private static final String _FINDER_COLUMN_UUID_UUID_1 = "journalArticleResource.uuid IS NULL";
2265 private static final String _FINDER_COLUMN_UUID_UUID_2 = "journalArticleResource.uuid = ?";
2266 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(journalArticleResource.uuid IS NULL OR journalArticleResource.uuid = ?)";
2267 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "journalArticleResource.uuid IS NULL AND ";
2268 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "journalArticleResource.uuid = ? AND ";
2269 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(journalArticleResource.uuid IS NULL OR journalArticleResource.uuid = ?) AND ";
2270 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "journalArticleResource.groupId = ?";
2271 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticleResource.groupId = ?";
2272 private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticleResource.groupId = ? AND ";
2273 private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticleResource.articleId IS NULL";
2274 private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticleResource.articleId = ?";
2275 private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticleResource.articleId IS NULL OR journalArticleResource.articleId = ?)";
2276 private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticleResource.";
2277 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticleResource exists with the primary key ";
2278 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticleResource exists with the key {";
2279 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
2280 private static Log _log = LogFactoryUtil.getLog(JournalArticleResourcePersistenceImpl.class);
2281 private static JournalArticleResource _nullJournalArticleResource = new JournalArticleResourceImpl() {
2282 @Override
2283 public Object clone() {
2284 return this;
2285 }
2286
2287 @Override
2288 public CacheModel<JournalArticleResource> toCacheModel() {
2289 return _nullJournalArticleResourceCacheModel;
2290 }
2291 };
2292
2293 private static CacheModel<JournalArticleResource> _nullJournalArticleResourceCacheModel =
2294 new CacheModel<JournalArticleResource>() {
2295 public JournalArticleResource toEntityModel() {
2296 return _nullJournalArticleResource;
2297 }
2298 };
2299 }