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