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