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.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     public JournalArticleResource updateImpl(
248         com.liferay.portlet.journal.model.JournalArticleResource journalArticleResource,
249         boolean merge) throws SystemException {
250         journalArticleResource = toUnwrappedModel(journalArticleResource);
251 
252         boolean isNew = journalArticleResource.isNew();
253 
254         JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
255 
256         Session session = null;
257 
258         try {
259             session = openSession();
260 
261             BatchSessionUtil.update(session, journalArticleResource, merge);
262 
263             journalArticleResource.setNew(false);
264         }
265         catch (Exception e) {
266             throw processException(e);
267         }
268         finally {
269             closeSession(session);
270         }
271 
272         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
273 
274         EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
275             JournalArticleResourceImpl.class,
276             journalArticleResource.getPrimaryKey(), journalArticleResource);
277 
278         if (!isNew &&
279                 ((journalArticleResource.getGroupId() != journalArticleResourceModelImpl.getOriginalGroupId()) ||
280                 !Validator.equals(journalArticleResource.getArticleId(),
281                     journalArticleResourceModelImpl.getOriginalArticleId()))) {
282             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
283                 new Object[] {
284                     new Long(journalArticleResourceModelImpl.getOriginalGroupId()),
285                     
286                 journalArticleResourceModelImpl.getOriginalArticleId()
287                 });
288         }
289 
290         if (isNew ||
291                 ((journalArticleResource.getGroupId() != journalArticleResourceModelImpl.getOriginalGroupId()) ||
292                 !Validator.equals(journalArticleResource.getArticleId(),
293                     journalArticleResourceModelImpl.getOriginalArticleId()))) {
294             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
295                 new Object[] {
296                     new Long(journalArticleResource.getGroupId()),
297                     
298                 journalArticleResource.getArticleId()
299                 }, journalArticleResource);
300         }
301 
302         return journalArticleResource;
303     }
304 
305     protected JournalArticleResource toUnwrappedModel(
306         JournalArticleResource journalArticleResource) {
307         if (journalArticleResource instanceof JournalArticleResourceImpl) {
308             return journalArticleResource;
309         }
310 
311         JournalArticleResourceImpl journalArticleResourceImpl = new JournalArticleResourceImpl();
312 
313         journalArticleResourceImpl.setNew(journalArticleResource.isNew());
314         journalArticleResourceImpl.setPrimaryKey(journalArticleResource.getPrimaryKey());
315 
316         journalArticleResourceImpl.setResourcePrimKey(journalArticleResource.getResourcePrimKey());
317         journalArticleResourceImpl.setGroupId(journalArticleResource.getGroupId());
318         journalArticleResourceImpl.setArticleId(journalArticleResource.getArticleId());
319 
320         return journalArticleResourceImpl;
321     }
322 
323     public JournalArticleResource findByPrimaryKey(Serializable primaryKey)
324         throws NoSuchModelException, SystemException {
325         return findByPrimaryKey(((Long)primaryKey).longValue());
326     }
327 
328     public JournalArticleResource findByPrimaryKey(long resourcePrimKey)
329         throws NoSuchArticleResourceException, SystemException {
330         JournalArticleResource journalArticleResource = fetchByPrimaryKey(resourcePrimKey);
331 
332         if (journalArticleResource == null) {
333             if (_log.isWarnEnabled()) {
334                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + resourcePrimKey);
335             }
336 
337             throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
338                 resourcePrimKey);
339         }
340 
341         return journalArticleResource;
342     }
343 
344     public JournalArticleResource fetchByPrimaryKey(Serializable primaryKey)
345         throws SystemException {
346         return fetchByPrimaryKey(((Long)primaryKey).longValue());
347     }
348 
349     public JournalArticleResource fetchByPrimaryKey(long resourcePrimKey)
350         throws SystemException {
351         JournalArticleResource journalArticleResource = (JournalArticleResource)EntityCacheUtil.getResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
352                 JournalArticleResourceImpl.class, resourcePrimKey, this);
353 
354         if (journalArticleResource == null) {
355             Session session = null;
356 
357             try {
358                 session = openSession();
359 
360                 journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
361                         new Long(resourcePrimKey));
362             }
363             catch (Exception e) {
364                 throw processException(e);
365             }
366             finally {
367                 if (journalArticleResource != null) {
368                     cacheResult(journalArticleResource);
369                 }
370 
371                 closeSession(session);
372             }
373         }
374 
375         return journalArticleResource;
376     }
377 
378     public List<JournalArticleResource> findByGroupId(long groupId)
379         throws SystemException {
380         Object[] finderArgs = new Object[] { new Long(groupId) };
381 
382         List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
383                 finderArgs, this);
384 
385         if (list == null) {
386             Session session = null;
387 
388             try {
389                 session = openSession();
390 
391                 StringBundler query = new StringBundler(2);
392 
393                 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
394 
395                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
396 
397                 String sql = query.toString();
398 
399                 Query q = session.createQuery(sql);
400 
401                 QueryPos qPos = QueryPos.getInstance(q);
402 
403                 qPos.add(groupId);
404 
405                 list = q.list();
406             }
407             catch (Exception e) {
408                 throw processException(e);
409             }
410             finally {
411                 if (list == null) {
412                     list = new ArrayList<JournalArticleResource>();
413                 }
414 
415                 cacheResult(list);
416 
417                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
418                     finderArgs, list);
419 
420                 closeSession(session);
421             }
422         }
423 
424         return list;
425     }
426 
427     public List<JournalArticleResource> findByGroupId(long groupId, int start,
428         int end) throws SystemException {
429         return findByGroupId(groupId, start, end, null);
430     }
431 
432     public List<JournalArticleResource> findByGroupId(long groupId, int start,
433         int end, OrderByComparator orderByComparator) throws SystemException {
434         Object[] finderArgs = new Object[] {
435                 new Long(groupId),
436                 
437                 String.valueOf(start), String.valueOf(end),
438                 String.valueOf(orderByComparator)
439             };
440 
441         List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
442                 finderArgs, this);
443 
444         if (list == null) {
445             Session session = null;
446 
447             try {
448                 session = openSession();
449 
450                 StringBundler query = null;
451 
452                 if (orderByComparator != null) {
453                     query = new StringBundler(3 +
454                             (orderByComparator.getOrderByFields().length * 3));
455                 }
456                 else {
457                     query = new StringBundler(2);
458                 }
459 
460                 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
461 
462                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
463 
464                 if (orderByComparator != null) {
465                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
466                         orderByComparator);
467                 }
468 
469                 String sql = query.toString();
470 
471                 Query q = session.createQuery(sql);
472 
473                 QueryPos qPos = QueryPos.getInstance(q);
474 
475                 qPos.add(groupId);
476 
477                 list = (List<JournalArticleResource>)QueryUtil.list(q,
478                         getDialect(), start, end);
479             }
480             catch (Exception e) {
481                 throw processException(e);
482             }
483             finally {
484                 if (list == null) {
485                     list = new ArrayList<JournalArticleResource>();
486                 }
487 
488                 cacheResult(list);
489 
490                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
491                     finderArgs, list);
492 
493                 closeSession(session);
494             }
495         }
496 
497         return list;
498     }
499 
500     public JournalArticleResource findByGroupId_First(long groupId,
501         OrderByComparator orderByComparator)
502         throws NoSuchArticleResourceException, SystemException {
503         List<JournalArticleResource> list = findByGroupId(groupId, 0, 1,
504                 orderByComparator);
505 
506         if (list.isEmpty()) {
507             StringBundler msg = new StringBundler(4);
508 
509             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
510 
511             msg.append("groupId=");
512             msg.append(groupId);
513 
514             msg.append(StringPool.CLOSE_CURLY_BRACE);
515 
516             throw new NoSuchArticleResourceException(msg.toString());
517         }
518         else {
519             return list.get(0);
520         }
521     }
522 
523     public JournalArticleResource findByGroupId_Last(long groupId,
524         OrderByComparator orderByComparator)
525         throws NoSuchArticleResourceException, SystemException {
526         int count = countByGroupId(groupId);
527 
528         List<JournalArticleResource> list = findByGroupId(groupId, count - 1,
529                 count, orderByComparator);
530 
531         if (list.isEmpty()) {
532             StringBundler msg = new StringBundler(4);
533 
534             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
535 
536             msg.append("groupId=");
537             msg.append(groupId);
538 
539             msg.append(StringPool.CLOSE_CURLY_BRACE);
540 
541             throw new NoSuchArticleResourceException(msg.toString());
542         }
543         else {
544             return list.get(0);
545         }
546     }
547 
548     public JournalArticleResource[] findByGroupId_PrevAndNext(
549         long resourcePrimKey, long groupId, OrderByComparator orderByComparator)
550         throws NoSuchArticleResourceException, SystemException {
551         JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
552 
553         int count = countByGroupId(groupId);
554 
555         Session session = null;
556 
557         try {
558             session = openSession();
559 
560             StringBundler query = null;
561 
562             if (orderByComparator != null) {
563                 query = new StringBundler(3 +
564                         (orderByComparator.getOrderByFields().length * 3));
565             }
566             else {
567                 query = new StringBundler(2);
568             }
569 
570             query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
571 
572             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
573 
574             if (orderByComparator != null) {
575                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
576                     orderByComparator);
577             }
578 
579             String sql = query.toString();
580 
581             Query q = session.createQuery(sql);
582 
583             QueryPos qPos = QueryPos.getInstance(q);
584 
585             qPos.add(groupId);
586 
587             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
588                     orderByComparator, journalArticleResource);
589 
590             JournalArticleResource[] array = new JournalArticleResourceImpl[3];
591 
592             array[0] = (JournalArticleResource)objArray[0];
593             array[1] = (JournalArticleResource)objArray[1];
594             array[2] = (JournalArticleResource)objArray[2];
595 
596             return array;
597         }
598         catch (Exception e) {
599             throw processException(e);
600         }
601         finally {
602             closeSession(session);
603         }
604     }
605 
606     public JournalArticleResource findByG_A(long groupId, String articleId)
607         throws NoSuchArticleResourceException, SystemException {
608         JournalArticleResource journalArticleResource = fetchByG_A(groupId,
609                 articleId);
610 
611         if (journalArticleResource == null) {
612             StringBundler msg = new StringBundler(6);
613 
614             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
615 
616             msg.append("groupId=");
617             msg.append(groupId);
618 
619             msg.append(", articleId=");
620             msg.append(articleId);
621 
622             msg.append(StringPool.CLOSE_CURLY_BRACE);
623 
624             if (_log.isWarnEnabled()) {
625                 _log.warn(msg.toString());
626             }
627 
628             throw new NoSuchArticleResourceException(msg.toString());
629         }
630 
631         return journalArticleResource;
632     }
633 
634     public JournalArticleResource fetchByG_A(long groupId, String articleId)
635         throws SystemException {
636         return fetchByG_A(groupId, articleId, true);
637     }
638 
639     public JournalArticleResource fetchByG_A(long groupId, String articleId,
640         boolean retrieveFromCache) throws SystemException {
641         Object[] finderArgs = new Object[] { new Long(groupId), articleId };
642 
643         Object result = null;
644 
645         if (retrieveFromCache) {
646             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A,
647                     finderArgs, this);
648         }
649 
650         if (result == null) {
651             Session session = null;
652 
653             try {
654                 session = openSession();
655 
656                 StringBundler query = new StringBundler(3);
657 
658                 query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
659 
660                 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
661 
662                 if (articleId == null) {
663                     query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
664                 }
665                 else {
666                     if (articleId.equals(StringPool.BLANK)) {
667                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
668                     }
669                     else {
670                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
671                     }
672                 }
673 
674                 String sql = query.toString();
675 
676                 Query q = session.createQuery(sql);
677 
678                 QueryPos qPos = QueryPos.getInstance(q);
679 
680                 qPos.add(groupId);
681 
682                 if (articleId != null) {
683                     qPos.add(articleId);
684                 }
685 
686                 List<JournalArticleResource> list = q.list();
687 
688                 result = list;
689 
690                 JournalArticleResource journalArticleResource = null;
691 
692                 if (list.isEmpty()) {
693                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
694                         finderArgs, list);
695                 }
696                 else {
697                     journalArticleResource = list.get(0);
698 
699                     cacheResult(journalArticleResource);
700 
701                     if ((journalArticleResource.getGroupId() != groupId) ||
702                             (journalArticleResource.getArticleId() == null) ||
703                             !journalArticleResource.getArticleId()
704                                                        .equals(articleId)) {
705                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
706                             finderArgs, journalArticleResource);
707                     }
708                 }
709 
710                 return journalArticleResource;
711             }
712             catch (Exception e) {
713                 throw processException(e);
714             }
715             finally {
716                 if (result == null) {
717                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
718                         finderArgs, new ArrayList<JournalArticleResource>());
719                 }
720 
721                 closeSession(session);
722             }
723         }
724         else {
725             if (result instanceof List<?>) {
726                 return null;
727             }
728             else {
729                 return (JournalArticleResource)result;
730             }
731         }
732     }
733 
734     public List<JournalArticleResource> findAll() throws SystemException {
735         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
736     }
737 
738     public List<JournalArticleResource> findAll(int start, int end)
739         throws SystemException {
740         return findAll(start, end, null);
741     }
742 
743     public List<JournalArticleResource> findAll(int start, int end,
744         OrderByComparator orderByComparator) throws SystemException {
745         Object[] finderArgs = new Object[] {
746                 String.valueOf(start), String.valueOf(end),
747                 String.valueOf(orderByComparator)
748             };
749 
750         List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
751                 finderArgs, this);
752 
753         if (list == null) {
754             Session session = null;
755 
756             try {
757                 session = openSession();
758 
759                 StringBundler query = null;
760                 String sql = null;
761 
762                 if (orderByComparator != null) {
763                     query = new StringBundler(2 +
764                             (orderByComparator.getOrderByFields().length * 3));
765 
766                     query.append(_SQL_SELECT_JOURNALARTICLERESOURCE);
767 
768                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
769                         orderByComparator);
770 
771                     sql = query.toString();
772                 }
773 
774                 sql = _SQL_SELECT_JOURNALARTICLERESOURCE;
775 
776                 Query q = session.createQuery(sql);
777 
778                 if (orderByComparator == null) {
779                     list = (List<JournalArticleResource>)QueryUtil.list(q,
780                             getDialect(), start, end, false);
781 
782                     Collections.sort(list);
783                 }
784                 else {
785                     list = (List<JournalArticleResource>)QueryUtil.list(q,
786                             getDialect(), start, end);
787                 }
788             }
789             catch (Exception e) {
790                 throw processException(e);
791             }
792             finally {
793                 if (list == null) {
794                     list = new ArrayList<JournalArticleResource>();
795                 }
796 
797                 cacheResult(list);
798 
799                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
800 
801                 closeSession(session);
802             }
803         }
804 
805         return list;
806     }
807 
808     public void removeByGroupId(long groupId) throws SystemException {
809         for (JournalArticleResource journalArticleResource : findByGroupId(
810                 groupId)) {
811             remove(journalArticleResource);
812         }
813     }
814 
815     public void removeByG_A(long groupId, String articleId)
816         throws NoSuchArticleResourceException, SystemException {
817         JournalArticleResource journalArticleResource = findByG_A(groupId,
818                 articleId);
819 
820         remove(journalArticleResource);
821     }
822 
823     public void removeAll() throws SystemException {
824         for (JournalArticleResource journalArticleResource : findAll()) {
825             remove(journalArticleResource);
826         }
827     }
828 
829     public int countByGroupId(long groupId) throws SystemException {
830         Object[] finderArgs = new Object[] { new Long(groupId) };
831 
832         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
833                 finderArgs, this);
834 
835         if (count == null) {
836             Session session = null;
837 
838             try {
839                 session = openSession();
840 
841                 StringBundler query = new StringBundler(2);
842 
843                 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
844 
845                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
846 
847                 String sql = query.toString();
848 
849                 Query q = session.createQuery(sql);
850 
851                 QueryPos qPos = QueryPos.getInstance(q);
852 
853                 qPos.add(groupId);
854 
855                 count = (Long)q.uniqueResult();
856             }
857             catch (Exception e) {
858                 throw processException(e);
859             }
860             finally {
861                 if (count == null) {
862                     count = Long.valueOf(0);
863                 }
864 
865                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
866                     finderArgs, count);
867 
868                 closeSession(session);
869             }
870         }
871 
872         return count.intValue();
873     }
874 
875     public int countByG_A(long groupId, String articleId)
876         throws SystemException {
877         Object[] finderArgs = new Object[] { new Long(groupId), articleId };
878 
879         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
880                 finderArgs, this);
881 
882         if (count == null) {
883             Session session = null;
884 
885             try {
886                 session = openSession();
887 
888                 StringBundler query = new StringBundler(3);
889 
890                 query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
891 
892                 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
893 
894                 if (articleId == null) {
895                     query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
896                 }
897                 else {
898                     if (articleId.equals(StringPool.BLANK)) {
899                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
900                     }
901                     else {
902                         query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
903                     }
904                 }
905 
906                 String sql = query.toString();
907 
908                 Query q = session.createQuery(sql);
909 
910                 QueryPos qPos = QueryPos.getInstance(q);
911 
912                 qPos.add(groupId);
913 
914                 if (articleId != null) {
915                     qPos.add(articleId);
916                 }
917 
918                 count = (Long)q.uniqueResult();
919             }
920             catch (Exception e) {
921                 throw processException(e);
922             }
923             finally {
924                 if (count == null) {
925                     count = Long.valueOf(0);
926                 }
927 
928                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
929                     count);
930 
931                 closeSession(session);
932             }
933         }
934 
935         return count.intValue();
936     }
937 
938     public int countAll() throws SystemException {
939         Object[] finderArgs = new Object[0];
940 
941         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
942                 finderArgs, this);
943 
944         if (count == null) {
945             Session session = null;
946 
947             try {
948                 session = openSession();
949 
950                 Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLERESOURCE);
951 
952                 count = (Long)q.uniqueResult();
953             }
954             catch (Exception e) {
955                 throw processException(e);
956             }
957             finally {
958                 if (count == null) {
959                     count = Long.valueOf(0);
960                 }
961 
962                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
963                     count);
964 
965                 closeSession(session);
966             }
967         }
968 
969         return count.intValue();
970     }
971 
972     public void afterPropertiesSet() {
973         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
974                     com.liferay.portal.util.PropsUtil.get(
975                         "value.object.listener.com.liferay.portlet.journal.model.JournalArticleResource")));
976 
977         if (listenerClassNames.length > 0) {
978             try {
979                 List<ModelListener<JournalArticleResource>> listenersList = new ArrayList<ModelListener<JournalArticleResource>>();
980 
981                 for (String listenerClassName : listenerClassNames) {
982                     listenersList.add((ModelListener<JournalArticleResource>)Class.forName(
983                             listenerClassName).newInstance());
984                 }
985 
986                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
987             }
988             catch (Exception e) {
989                 _log.error(e);
990             }
991         }
992     }
993 
994     @BeanReference(type = JournalArticlePersistence.class)
995     protected JournalArticlePersistence journalArticlePersistence;
996     @BeanReference(type = JournalArticleImagePersistence.class)
997     protected JournalArticleImagePersistence journalArticleImagePersistence;
998     @BeanReference(type = JournalArticleResourcePersistence.class)
999     protected JournalArticleResourcePersistence journalArticleResourcePersistence;
1000    @BeanReference(type = JournalContentSearchPersistence.class)
1001    protected JournalContentSearchPersistence journalContentSearchPersistence;
1002    @BeanReference(type = JournalFeedPersistence.class)
1003    protected JournalFeedPersistence journalFeedPersistence;
1004    @BeanReference(type = JournalStructurePersistence.class)
1005    protected JournalStructurePersistence journalStructurePersistence;
1006    @BeanReference(type = JournalTemplatePersistence.class)
1007    protected JournalTemplatePersistence journalTemplatePersistence;
1008    @BeanReference(type = ResourcePersistence.class)
1009    protected ResourcePersistence resourcePersistence;
1010    @BeanReference(type = UserPersistence.class)
1011    protected UserPersistence userPersistence;
1012    private static final String _SQL_SELECT_JOURNALARTICLERESOURCE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource";
1013    private static final String _SQL_SELECT_JOURNALARTICLERESOURCE_WHERE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource WHERE ";
1014    private static final String _SQL_COUNT_JOURNALARTICLERESOURCE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource";
1015    private static final String _SQL_COUNT_JOURNALARTICLERESOURCE_WHERE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource WHERE ";
1016    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticleResource.groupId = ?";
1017    private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticleResource.groupId = ? AND ";
1018    private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticleResource.articleId IS NULL";
1019    private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticleResource.articleId = ?";
1020    private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticleResource.articleId IS NULL OR journalArticleResource.articleId = ?)";
1021    private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticleResource.";
1022    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticleResource exists with the primary key ";
1023    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticleResource exists with the key {";
1024    private static Log _log = LogFactoryUtil.getLog(JournalArticleResourcePersistenceImpl.class);
1025}