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