1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.journal.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.Session;
27  import com.liferay.portal.kernel.exception.SystemException;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.InstanceFactory;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.kernel.util.Validator;
37  import com.liferay.portal.model.ModelListener;
38  import com.liferay.portal.service.persistence.BatchSessionUtil;
39  import com.liferay.portal.service.persistence.ResourcePersistence;
40  import com.liferay.portal.service.persistence.UserPersistence;
41  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
42  
43  import com.liferay.portlet.journal.NoSuchArticleResourceException;
44  import com.liferay.portlet.journal.model.JournalArticleResource;
45  import com.liferay.portlet.journal.model.impl.JournalArticleResourceImpl;
46  import com.liferay.portlet.journal.model.impl.JournalArticleResourceModelImpl;
47  
48  import java.io.Serializable;
49  
50  import java.util.ArrayList;
51  import java.util.Collections;
52  import java.util.List;
53  
54  /**
55   * <a href="JournalArticleResourcePersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * <p>
58   * ServiceBuilder generated this class. Modifications in this class will be
59   * overwritten the next time is generated.
60   * </p>
61   *
62   * @author    Brian Wing Shun Chan
63   * @see       JournalArticleResourcePersistence
64   * @see       JournalArticleResourceUtil
65   * @generated
66   */
67  public class JournalArticleResourcePersistenceImpl extends BasePersistenceImpl<JournalArticleResource>
68      implements JournalArticleResourcePersistence {
69      public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleResourceImpl.class.getName();
70      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
71          ".List";
72      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
73              JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
74              FINDER_CLASS_NAME_LIST, "findByGroupId",
75              new String[] {
76                  Long.class.getName(),
77                  
78              "java.lang.Integer", "java.lang.Integer",
79                  "com.liferay.portal.kernel.util.OrderByComparator"
80              });
81      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
82              JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
83              FINDER_CLASS_NAME_LIST, "countByGroupId",
84              new String[] { Long.class.getName() });
85      public static final FinderPath FINDER_PATH_FETCH_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
86              JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
87              FINDER_CLASS_NAME_ENTITY, "fetchByG_A",
88              new String[] { Long.class.getName(), String.class.getName() });
89      public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
90              JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
91              FINDER_CLASS_NAME_LIST, "countByG_A",
92              new String[] { Long.class.getName(), String.class.getName() });
93      public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
94              JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
95              FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
96      public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
97              JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
99  
100     public void cacheResult(JournalArticleResource journalArticleResource) {
101         EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
102             JournalArticleResourceImpl.class,
103             journalArticleResource.getPrimaryKey(), journalArticleResource);
104 
105         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
106             new Object[] {
107                 new Long(journalArticleResource.getGroupId()),
108                 
109             journalArticleResource.getArticleId()
110             }, journalArticleResource);
111     }
112 
113     public void cacheResult(
114         List<JournalArticleResource> journalArticleResources) {
115         for (JournalArticleResource journalArticleResource : journalArticleResources) {
116             if (EntityCacheUtil.getResult(
117                         JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
118                         JournalArticleResourceImpl.class,
119                         journalArticleResource.getPrimaryKey(), this) == null) {
120                 cacheResult(journalArticleResource);
121             }
122         }
123     }
124 
125     public void clearCache() {
126         CacheRegistry.clear(JournalArticleResourceImpl.class.getName());
127         EntityCacheUtil.clearCache(JournalArticleResourceImpl.class.getName());
128         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
129         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
130     }
131 
132     public void clearCache(JournalArticleResource journalArticleResource) {
133         EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
134             JournalArticleResourceImpl.class,
135             journalArticleResource.getPrimaryKey());
136 
137         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
138             new Object[] {
139                 new Long(journalArticleResource.getGroupId()),
140                 
141             journalArticleResource.getArticleId()
142             });
143     }
144 
145     public JournalArticleResource create(long resourcePrimKey) {
146         JournalArticleResource journalArticleResource = new JournalArticleResourceImpl();
147 
148         journalArticleResource.setNew(true);
149         journalArticleResource.setPrimaryKey(resourcePrimKey);
150 
151         return journalArticleResource;
152     }
153 
154     public JournalArticleResource remove(Serializable primaryKey)
155         throws NoSuchModelException, SystemException {
156         return remove(((Long)primaryKey).longValue());
157     }
158 
159     public JournalArticleResource remove(long resourcePrimKey)
160         throws NoSuchArticleResourceException, SystemException {
161         Session session = null;
162 
163         try {
164             session = openSession();
165 
166             JournalArticleResource journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
167                     new Long(resourcePrimKey));
168 
169             if (journalArticleResource == null) {
170                 if (_log.isWarnEnabled()) {
171                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
172                         resourcePrimKey);
173                 }
174 
175                 throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
176                     resourcePrimKey);
177             }
178 
179             return remove(journalArticleResource);
180         }
181         catch (NoSuchArticleResourceException nsee) {
182             throw nsee;
183         }
184         catch (Exception e) {
185             throw processException(e);
186         }
187         finally {
188             closeSession(session);
189         }
190     }
191 
192     public JournalArticleResource remove(
193         JournalArticleResource journalArticleResource)
194         throws SystemException {
195         for (ModelListener<JournalArticleResource> listener : listeners) {
196             listener.onBeforeRemove(journalArticleResource);
197         }
198 
199         journalArticleResource = removeImpl(journalArticleResource);
200 
201         for (ModelListener<JournalArticleResource> listener : listeners) {
202             listener.onAfterRemove(journalArticleResource);
203         }
204 
205         return journalArticleResource;
206     }
207 
208     protected JournalArticleResource removeImpl(
209         JournalArticleResource journalArticleResource)
210         throws SystemException {
211         journalArticleResource = toUnwrappedModel(journalArticleResource);
212 
213         Session session = null;
214 
215         try {
216             session = openSession();
217 
218             if (journalArticleResource.isCachedModel() ||
219                     BatchSessionUtil.isEnabled()) {
220                 Object staleObject = session.get(JournalArticleResourceImpl.class,
221                         journalArticleResource.getPrimaryKeyObj());
222 
223                 if (staleObject != null) {
224                     session.evict(staleObject);
225                 }
226             }
227 
228             session.delete(journalArticleResource);
229 
230             session.flush();
231         }
232         catch (Exception e) {
233             throw processException(e);
234         }
235         finally {
236             closeSession(session);
237         }
238 
239         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
240 
241         JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
242 
243         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
244             new Object[] {
245                 new Long(journalArticleResourceModelImpl.getOriginalGroupId()),
246                 
247             journalArticleResourceModelImpl.getOriginalArticleId()
248             });
249 
250         EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
251             JournalArticleResourceImpl.class,
252             journalArticleResource.getPrimaryKey());
253 
254         return journalArticleResource;
255     }
256 
257     public JournalArticleResource updateImpl(
258         com.liferay.portlet.journal.model.JournalArticleResource journalArticleResource,
259         boolean merge) throws SystemException {
260         journalArticleResource = toUnwrappedModel(journalArticleResource);
261 
262         boolean isNew = journalArticleResource.isNew();
263 
264         JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
265 
266         Session session = null;
267 
268         try {
269             session = openSession();
270 
271             BatchSessionUtil.update(session, journalArticleResource, merge);
272 
273             journalArticleResource.setNew(false);
274         }
275         catch (Exception e) {
276             throw processException(e);
277         }
278         finally {
279             closeSession(session);
280         }
281 
282         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
283 
284         EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
285             JournalArticleResourceImpl.class,
286             journalArticleResource.getPrimaryKey(), journalArticleResource);
287 
288         if (!isNew &&
289                 ((journalArticleResource.getGroupId() != journalArticleResourceModelImpl.getOriginalGroupId()) ||
290                 !Validator.equals(journalArticleResource.getArticleId(),
291                     journalArticleResourceModelImpl.getOriginalArticleId()))) {
292             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
293                 new Object[] {
294                     new Long(journalArticleResourceModelImpl.getOriginalGroupId()),
295                     
296                 journalArticleResourceModelImpl.getOriginalArticleId()
297                 });
298         }
299 
300         if (isNew ||
301                 ((journalArticleResource.getGroupId() != journalArticleResourceModelImpl.getOriginalGroupId()) ||
302                 !Validator.equals(journalArticleResource.getArticleId(),
303                     journalArticleResourceModelImpl.getOriginalArticleId()))) {
304             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
305                 new Object[] {
306                     new Long(journalArticleResource.getGroupId()),
307                     
308                 journalArticleResource.getArticleId()
309                 }, journalArticleResource);
310         }
311 
312         return journalArticleResource;
313     }
314 
315     protected JournalArticleResource toUnwrappedModel(
316         JournalArticleResource journalArticleResource) {
317         if (journalArticleResource instanceof JournalArticleResourceImpl) {
318             return journalArticleResource;
319         }
320 
321         JournalArticleResourceImpl journalArticleResourceImpl = new JournalArticleResourceImpl();
322 
323         journalArticleResourceImpl.setNew(journalArticleResource.isNew());
324         journalArticleResourceImpl.setPrimaryKey(journalArticleResource.getPrimaryKey());
325 
326         journalArticleResourceImpl.setResourcePrimKey(journalArticleResource.getResourcePrimKey());
327         journalArticleResourceImpl.setGroupId(journalArticleResource.getGroupId());
328         journalArticleResourceImpl.setArticleId(journalArticleResource.getArticleId());
329 
330         return journalArticleResourceImpl;
331     }
332 
333     public JournalArticleResource findByPrimaryKey(Serializable primaryKey)
334         throws NoSuchModelException, SystemException {
335         return findByPrimaryKey(((Long)primaryKey).longValue());
336     }
337 
338     public JournalArticleResource findByPrimaryKey(long resourcePrimKey)
339         throws NoSuchArticleResourceException, SystemException {
340         JournalArticleResource journalArticleResource = fetchByPrimaryKey(resourcePrimKey);
341 
342         if (journalArticleResource == null) {
343             if (_log.isWarnEnabled()) {
344                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + resourcePrimKey);
345             }
346 
347             throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
348                 resourcePrimKey);
349         }
350 
351         return journalArticleResource;
352     }
353 
354     public JournalArticleResource fetchByPrimaryKey(Serializable primaryKey)
355         throws SystemException {
356         return fetchByPrimaryKey(((Long)primaryKey).longValue());
357     }
358 
359     public JournalArticleResource fetchByPrimaryKey(long resourcePrimKey)
360         throws SystemException {
361         JournalArticleResource journalArticleResource = (JournalArticleResource)EntityCacheUtil.getResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
362                 JournalArticleResourceImpl.class, resourcePrimKey, this);
363 
364         if (journalArticleResource == null) {
365             Session session = null;
366 
367             try {
368                 session = openSession();
369 
370                 journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
371                         new Long(resourcePrimKey));
372             }
373             catch (Exception e) {
374                 throw processException(e);
375             }
376             finally {
377                 if (journalArticleResource != null) {
378                     cacheResult(journalArticleResource);
379                 }
380 
381                 closeSession(session);
382             }
383         }
384 
385         return journalArticleResource;
386     }
387 
388     public List<JournalArticleResource> findByGroupId(long groupId)
389         throws SystemException {
390         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
391     }
392 
393     public List<JournalArticleResource> findByGroupId(long groupId, int start,
394         int end) throws SystemException {
395         return findByGroupId(groupId, start, end, null);
396     }
397 
398     public List<JournalArticleResource> findByGroupId(long groupId, int start,
399         int end, OrderByComparator orderByComparator) throws SystemException {
400         Object[] finderArgs = new Object[] {
401                 new Long(groupId),
402                 
403                 String.valueOf(start), String.valueOf(end),
404                 String.valueOf(orderByComparator)
405             };
406 
407         List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
408                 finderArgs, this);
409 
410         if (list == null) {
411             Session session = null;
412 
413             try {
414                 session = openSession();
415 
416                 StringBundler query = null;
417 
418                 if (orderByComparator != null) {
419                     query = new StringBundler(3 +
420                             (orderByComparator.getOrderByFields().length * 3));
421                 }
422                 else {
423                     query = new StringBundler(2);
424                 }
425 
426                 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
427 
428                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
429 
430                 if (orderByComparator != null) {
431                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
432                         orderByComparator);
433                 }
434 
435                 String sql = query.toString();
436 
437                 Query q = session.createQuery(sql);
438 
439                 QueryPos qPos = QueryPos.getInstance(q);
440 
441                 qPos.add(groupId);
442 
443                 list = (List<JournalArticleResource>)QueryUtil.list(q,
444                         getDialect(), start, end);
445             }
446             catch (Exception e) {
447                 throw processException(e);
448             }
449             finally {
450                 if (list == null) {
451                     list = new ArrayList<JournalArticleResource>();
452                 }
453 
454                 cacheResult(list);
455 
456                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
457                     finderArgs, list);
458 
459                 closeSession(session);
460             }
461         }
462 
463         return list;
464     }
465 
466     public JournalArticleResource findByGroupId_First(long groupId,
467         OrderByComparator orderByComparator)
468         throws NoSuchArticleResourceException, SystemException {
469         List<JournalArticleResource> list = findByGroupId(groupId, 0, 1,
470                 orderByComparator);
471 
472         if (list.isEmpty()) {
473             StringBundler msg = new StringBundler(4);
474 
475             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
476 
477             msg.append("groupId=");
478             msg.append(groupId);
479 
480             msg.append(StringPool.CLOSE_CURLY_BRACE);
481 
482             throw new NoSuchArticleResourceException(msg.toString());
483         }
484         else {
485             return list.get(0);
486         }
487     }
488 
489     public JournalArticleResource findByGroupId_Last(long groupId,
490         OrderByComparator orderByComparator)
491         throws NoSuchArticleResourceException, SystemException {
492         int count = countByGroupId(groupId);
493 
494         List<JournalArticleResource> list = findByGroupId(groupId, count - 1,
495                 count, orderByComparator);
496 
497         if (list.isEmpty()) {
498             StringBundler msg = new StringBundler(4);
499 
500             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
501 
502             msg.append("groupId=");
503             msg.append(groupId);
504 
505             msg.append(StringPool.CLOSE_CURLY_BRACE);
506 
507             throw new NoSuchArticleResourceException(msg.toString());
508         }
509         else {
510             return list.get(0);
511         }
512     }
513 
514     public JournalArticleResource[] findByGroupId_PrevAndNext(
515         long resourcePrimKey, long groupId, OrderByComparator orderByComparator)
516         throws NoSuchArticleResourceException, SystemException {
517         JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
518 
519         Session session = null;
520 
521         try {
522             session = openSession();
523 
524             JournalArticleResource[] array = new JournalArticleResourceImpl[3];
525 
526             array[0] = getByGroupId_PrevAndNext(session,
527                     journalArticleResource, groupId, orderByComparator, true);
528 
529             array[1] = journalArticleResource;
530 
531             array[2] = getByGroupId_PrevAndNext(session,
532                     journalArticleResource, groupId, orderByComparator, false);
533 
534             return array;
535         }
536         catch (Exception e) {
537             throw processException(e);
538         }
539         finally {
540             closeSession(session);
541         }
542     }
543 
544     protected JournalArticleResource getByGroupId_PrevAndNext(Session session,
545         JournalArticleResource journalArticleResource, long groupId,
546         OrderByComparator orderByComparator, boolean previous) {
547         StringBundler query = null;
548 
549         if (orderByComparator != null) {
550             query = new StringBundler(6 +
551                     (orderByComparator.getOrderByFields().length * 6));
552         }
553         else {
554             query = new StringBundler(3);
555         }
556 
557         query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
558 
559         query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
560 
561         if (orderByComparator != null) {
562             String[] orderByFields = orderByComparator.getOrderByFields();
563 
564             if (orderByFields.length > 0) {
565                 query.append(WHERE_AND);
566             }
567 
568             for (int i = 0; i < orderByFields.length; i++) {
569                 query.append(_ORDER_BY_ENTITY_ALIAS);
570                 query.append(orderByFields[i]);
571 
572                 if ((i + 1) < orderByFields.length) {
573                     if (orderByComparator.isAscending() ^ previous) {
574                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
575                     }
576                     else {
577                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
578                     }
579                 }
580                 else {
581                     if (orderByComparator.isAscending() ^ previous) {
582                         query.append(WHERE_GREATER_THAN);
583                     }
584                     else {
585                         query.append(WHERE_LESSER_THAN);
586                     }
587                 }
588             }
589 
590             query.append(ORDER_BY_CLAUSE);
591 
592             for (int i = 0; i < orderByFields.length; i++) {
593                 query.append(_ORDER_BY_ENTITY_ALIAS);
594                 query.append(orderByFields[i]);
595 
596                 if ((i + 1) < orderByFields.length) {
597                     if (orderByComparator.isAscending() ^ previous) {
598                         query.append(ORDER_BY_ASC_HAS_NEXT);
599                     }
600                     else {
601                         query.append(ORDER_BY_DESC_HAS_NEXT);
602                     }
603                 }
604                 else {
605                     if (orderByComparator.isAscending() ^ previous) {
606                         query.append(ORDER_BY_ASC);
607                     }
608                     else {
609                         query.append(ORDER_BY_DESC);
610                     }
611                 }
612             }
613         }
614 
615         String sql = query.toString();
616 
617         Query q = session.createQuery(sql);
618 
619         q.setFirstResult(0);
620         q.setMaxResults(2);
621 
622         QueryPos qPos = QueryPos.getInstance(q);
623 
624         qPos.add(groupId);
625 
626         if (orderByComparator != null) {
627             Object[] values = orderByComparator.getOrderByValues(journalArticleResource);
628 
629             for (Object value : values) {
630                 qPos.add(value);
631             }
632         }
633 
634         List<JournalArticleResource> list = q.list();
635 
636         if (list.size() == 2) {
637             return list.get(1);
638         }
639         else {
640             return null;
641         }
642     }
643 
644     public JournalArticleResource findByG_A(long groupId, String articleId)
645         throws NoSuchArticleResourceException, SystemException {
646         JournalArticleResource journalArticleResource = fetchByG_A(groupId,
647                 articleId);
648 
649         if (journalArticleResource == null) {
650             StringBundler msg = new StringBundler(6);
651 
652             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
653 
654             msg.append("groupId=");
655             msg.append(groupId);
656 
657             msg.append(", articleId=");
658             msg.append(articleId);
659 
660             msg.append(StringPool.CLOSE_CURLY_BRACE);
661 
662             if (_log.isWarnEnabled()) {
663                 _log.warn(msg.toString());
664             }
665 
666             throw new NoSuchArticleResourceException(msg.toString());
667         }
668 
669         return journalArticleResource;
670     }
671 
672     public JournalArticleResource fetchByG_A(long groupId, String articleId)
673         throws SystemException {
674         return fetchByG_A(groupId, articleId, true);
675     }
676 
677     public JournalArticleResource fetchByG_A(long groupId, String articleId,
678         boolean retrieveFromCache) throws SystemException {
679         Object[] finderArgs = new Object[] { new Long(groupId), articleId };
680 
681         Object result = null;
682 
683         if (retrieveFromCache) {
684             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A,
685                     finderArgs, this);
686         }
687 
688         if (result == null) {
689             Session session = null;
690 
691             try {
692                 session = openSession();
693 
694                 StringBundler query = new StringBundler(3);
695 
696                 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
697 
698                 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
699 
700                 if (articleId == null) {
701                     query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
702                 }
703                 else {
704                     if (articleId.equals(StringPool.BLANK)) {
705                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
706                     }
707                     else {
708                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
709                     }
710                 }
711 
712                 String sql = query.toString();
713 
714                 Query q = session.createQuery(sql);
715 
716                 QueryPos qPos = QueryPos.getInstance(q);
717 
718                 qPos.add(groupId);
719 
720                 if (articleId != null) {
721                     qPos.add(articleId);
722                 }
723 
724                 List<JournalArticleResource> list = q.list();
725 
726                 result = list;
727 
728                 JournalArticleResource journalArticleResource = null;
729 
730                 if (list.isEmpty()) {
731                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
732                         finderArgs, list);
733                 }
734                 else {
735                     journalArticleResource = list.get(0);
736 
737                     cacheResult(journalArticleResource);
738 
739                     if ((journalArticleResource.getGroupId() != groupId) ||
740                             (journalArticleResource.getArticleId() == null) ||
741                             !journalArticleResource.getArticleId()
742                                                        .equals(articleId)) {
743                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
744                             finderArgs, journalArticleResource);
745                     }
746                 }
747 
748                 return journalArticleResource;
749             }
750             catch (Exception e) {
751                 throw processException(e);
752             }
753             finally {
754                 if (result == null) {
755                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
756                         finderArgs, new ArrayList<JournalArticleResource>());
757                 }
758 
759                 closeSession(session);
760             }
761         }
762         else {
763             if (result instanceof List<?>) {
764                 return null;
765             }
766             else {
767                 return (JournalArticleResource)result;
768             }
769         }
770     }
771 
772     public List<JournalArticleResource> findAll() throws SystemException {
773         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
774     }
775 
776     public List<JournalArticleResource> findAll(int start, int end)
777         throws SystemException {
778         return findAll(start, end, null);
779     }
780 
781     public List<JournalArticleResource> findAll(int start, int end,
782         OrderByComparator orderByComparator) throws SystemException {
783         Object[] finderArgs = new Object[] {
784                 String.valueOf(start), String.valueOf(end),
785                 String.valueOf(orderByComparator)
786             };
787 
788         List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
789                 finderArgs, this);
790 
791         if (list == null) {
792             Session session = null;
793 
794             try {
795                 session = openSession();
796 
797                 StringBundler query = null;
798                 String sql = null;
799 
800                 if (orderByComparator != null) {
801                     query = new StringBundler(2 +
802                             (orderByComparator.getOrderByFields().length * 3));
803 
804                     query.append(_SQL_SELECT_JOURNALARTICLERESOURCE);
805 
806                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
807                         orderByComparator);
808 
809                     sql = query.toString();
810                 }
811 
812                 sql = _SQL_SELECT_JOURNALARTICLERESOURCE;
813 
814                 Query q = session.createQuery(sql);
815 
816                 if (orderByComparator == null) {
817                     list = (List<JournalArticleResource>)QueryUtil.list(q,
818                             getDialect(), start, end, false);
819 
820                     Collections.sort(list);
821                 }
822                 else {
823                     list = (List<JournalArticleResource>)QueryUtil.list(q,
824                             getDialect(), start, end);
825                 }
826             }
827             catch (Exception e) {
828                 throw processException(e);
829             }
830             finally {
831                 if (list == null) {
832                     list = new ArrayList<JournalArticleResource>();
833                 }
834 
835                 cacheResult(list);
836 
837                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
838 
839                 closeSession(session);
840             }
841         }
842 
843         return list;
844     }
845 
846     public void removeByGroupId(long groupId) throws SystemException {
847         for (JournalArticleResource journalArticleResource : findByGroupId(
848                 groupId)) {
849             remove(journalArticleResource);
850         }
851     }
852 
853     public void removeByG_A(long groupId, String articleId)
854         throws NoSuchArticleResourceException, SystemException {
855         JournalArticleResource journalArticleResource = findByG_A(groupId,
856                 articleId);
857 
858         remove(journalArticleResource);
859     }
860 
861     public void removeAll() throws SystemException {
862         for (JournalArticleResource journalArticleResource : findAll()) {
863             remove(journalArticleResource);
864         }
865     }
866 
867     public int countByGroupId(long groupId) throws SystemException {
868         Object[] finderArgs = new Object[] { new Long(groupId) };
869 
870         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
871                 finderArgs, this);
872 
873         if (count == null) {
874             Session session = null;
875 
876             try {
877                 session = openSession();
878 
879                 StringBundler query = new StringBundler(2);
880 
881                 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
882 
883                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
884 
885                 String sql = query.toString();
886 
887                 Query q = session.createQuery(sql);
888 
889                 QueryPos qPos = QueryPos.getInstance(q);
890 
891                 qPos.add(groupId);
892 
893                 count = (Long)q.uniqueResult();
894             }
895             catch (Exception e) {
896                 throw processException(e);
897             }
898             finally {
899                 if (count == null) {
900                     count = Long.valueOf(0);
901                 }
902 
903                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
904                     finderArgs, count);
905 
906                 closeSession(session);
907             }
908         }
909 
910         return count.intValue();
911     }
912 
913     public int countByG_A(long groupId, String articleId)
914         throws SystemException {
915         Object[] finderArgs = new Object[] { new Long(groupId), articleId };
916 
917         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
918                 finderArgs, this);
919 
920         if (count == null) {
921             Session session = null;
922 
923             try {
924                 session = openSession();
925 
926                 StringBundler query = new StringBundler(3);
927 
928                 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
929 
930                 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
931 
932                 if (articleId == null) {
933                     query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
934                 }
935                 else {
936                     if (articleId.equals(StringPool.BLANK)) {
937                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
938                     }
939                     else {
940                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
941                     }
942                 }
943 
944                 String sql = query.toString();
945 
946                 Query q = session.createQuery(sql);
947 
948                 QueryPos qPos = QueryPos.getInstance(q);
949 
950                 qPos.add(groupId);
951 
952                 if (articleId != null) {
953                     qPos.add(articleId);
954                 }
955 
956                 count = (Long)q.uniqueResult();
957             }
958             catch (Exception e) {
959                 throw processException(e);
960             }
961             finally {
962                 if (count == null) {
963                     count = Long.valueOf(0);
964                 }
965 
966                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
967                     count);
968 
969                 closeSession(session);
970             }
971         }
972 
973         return count.intValue();
974     }
975 
976     public int countAll() throws SystemException {
977         Object[] finderArgs = new Object[0];
978 
979         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
980                 finderArgs, this);
981 
982         if (count == null) {
983             Session session = null;
984 
985             try {
986                 session = openSession();
987 
988                 Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLERESOURCE);
989 
990                 count = (Long)q.uniqueResult();
991             }
992             catch (Exception e) {
993                 throw processException(e);
994             }
995             finally {
996                 if (count == null) {
997                     count = Long.valueOf(0);
998                 }
999 
1000                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1001                    count);
1002
1003                closeSession(session);
1004            }
1005        }
1006
1007        return count.intValue();
1008    }
1009
1010    public void afterPropertiesSet() {
1011        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1012                    com.liferay.portal.util.PropsUtil.get(
1013                        "value.object.listener.com.liferay.portlet.journal.model.JournalArticleResource")));
1014
1015        if (listenerClassNames.length > 0) {
1016            try {
1017                List<ModelListener<JournalArticleResource>> listenersList = new ArrayList<ModelListener<JournalArticleResource>>();
1018
1019                for (String listenerClassName : listenerClassNames) {
1020                    listenersList.add((ModelListener<JournalArticleResource>)InstanceFactory.newInstance(
1021                            listenerClassName));
1022                }
1023
1024                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1025            }
1026            catch (Exception e) {
1027                _log.error(e);
1028            }
1029        }
1030    }
1031
1032    @BeanReference(type = JournalArticlePersistence.class)
1033    protected JournalArticlePersistence journalArticlePersistence;
1034    @BeanReference(type = JournalArticleImagePersistence.class)
1035    protected JournalArticleImagePersistence journalArticleImagePersistence;
1036    @BeanReference(type = JournalArticleResourcePersistence.class)
1037    protected JournalArticleResourcePersistence journalArticleResourcePersistence;
1038    @BeanReference(type = JournalContentSearchPersistence.class)
1039    protected JournalContentSearchPersistence journalContentSearchPersistence;
1040    @BeanReference(type = JournalFeedPersistence.class)
1041    protected JournalFeedPersistence journalFeedPersistence;
1042    @BeanReference(type = JournalStructurePersistence.class)
1043    protected JournalStructurePersistence journalStructurePersistence;
1044    @BeanReference(type = JournalTemplatePersistence.class)
1045    protected JournalTemplatePersistence journalTemplatePersistence;
1046    @BeanReference(type = ResourcePersistence.class)
1047    protected ResourcePersistence resourcePersistence;
1048    @BeanReference(type = UserPersistence.class)
1049    protected UserPersistence userPersistence;
1050    private static final String _SQL_SELECT_JOURNALARTICLERESOURCE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource";
1051    private static final String _SQL_SELECT_JOURNALARTICLERESOURCE_WHERE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource WHERE ";
1052    private static final String _SQL_COUNT_JOURNALARTICLERESOURCE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource";
1053    private static final String _SQL_COUNT_JOURNALARTICLERESOURCE_WHERE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource WHERE ";
1054    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticleResource.groupId = ?";
1055    private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticleResource.groupId = ? AND ";
1056    private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticleResource.articleId IS NULL";
1057    private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticleResource.articleId = ?";
1058    private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticleResource.articleId IS NULL OR journalArticleResource.articleId = ?)";
1059    private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticleResource.";
1060    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticleResource exists with the primary key ";
1061    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticleResource exists with the key {";
1062    private static Log _log = LogFactoryUtil.getLog(JournalArticleResourcePersistenceImpl.class);
1063}