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