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