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