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