1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.journal.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.Session;
27  import com.liferay.portal.kernel.exception.SystemException;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.OrderByComparator;
32  import com.liferay.portal.kernel.util.StringBundler;
33  import com.liferay.portal.kernel.util.StringPool;
34  import com.liferay.portal.kernel.util.StringUtil;
35  import com.liferay.portal.kernel.util.Validator;
36  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
37  import com.liferay.portal.model.ModelListener;
38  import com.liferay.portal.service.persistence.BatchSessionUtil;
39  import com.liferay.portal.service.persistence.CompanyPersistence;
40  import com.liferay.portal.service.persistence.GroupPersistence;
41  import com.liferay.portal.service.persistence.ImagePersistence;
42  import com.liferay.portal.service.persistence.PortletPreferencesPersistence;
43  import com.liferay.portal.service.persistence.ResourcePersistence;
44  import com.liferay.portal.service.persistence.SubscriptionPersistence;
45  import com.liferay.portal.service.persistence.UserPersistence;
46  import com.liferay.portal.service.persistence.WorkflowInstanceLinkPersistence;
47  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
48  
49  import com.liferay.portlet.asset.service.persistence.AssetCategoryPersistence;
50  import com.liferay.portlet.asset.service.persistence.AssetEntryPersistence;
51  import com.liferay.portlet.asset.service.persistence.AssetTagPersistence;
52  import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
53  import com.liferay.portlet.journal.NoSuchArticleException;
54  import com.liferay.portlet.journal.model.JournalArticle;
55  import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
56  import com.liferay.portlet.journal.model.impl.JournalArticleModelImpl;
57  import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
58  import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
59  
60  import java.io.Serializable;
61  
62  import java.util.ArrayList;
63  import java.util.Collections;
64  import java.util.List;
65  
66  /**
67   * <a href="JournalArticlePersistenceImpl.java.html"><b><i>View Source</i></b></a>
68   *
69   * <p>
70   * ServiceBuilder generated this class. Modifications in this class will be
71   * overwritten the next time is generated.
72   * </p>
73   *
74   * @author    Brian Wing Shun Chan
75   * @see       JournalArticlePersistence
76   * @see       JournalArticleUtil
77   * @generated
78   */
79  public class JournalArticlePersistenceImpl extends BasePersistenceImpl<JournalArticle>
80      implements JournalArticlePersistence {
81      public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleImpl.class.getName();
82      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
83          ".List";
84      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
85              JournalArticleModelImpl.FINDER_CACHE_ENABLED,
86              FINDER_CLASS_NAME_LIST, "findByUuid",
87              new String[] { String.class.getName() });
88      public static final FinderPath FINDER_PATH_FIND_BY_OBC_UUID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
89              JournalArticleModelImpl.FINDER_CACHE_ENABLED,
90              FINDER_CLASS_NAME_LIST, "findByUuid",
91              new String[] {
92                  String.class.getName(),
93                  
94              "java.lang.Integer", "java.lang.Integer",
95                  "com.liferay.portal.kernel.util.OrderByComparator"
96              });
97      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
98              JournalArticleModelImpl.FINDER_CACHE_ENABLED,
99              FINDER_CLASS_NAME_LIST, "countByUuid",
100             new String[] { String.class.getName() });
101     public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
102             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
103             FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
104             new String[] { String.class.getName(), Long.class.getName() });
105     public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
106             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
107             FINDER_CLASS_NAME_LIST, "countByUUID_G",
108             new String[] { String.class.getName(), Long.class.getName() });
109     public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
110             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
111             FINDER_CLASS_NAME_LIST, "findByGroupId",
112             new String[] { Long.class.getName() });
113     public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
114             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
115             FINDER_CLASS_NAME_LIST, "findByGroupId",
116             new String[] {
117                 Long.class.getName(),
118                 
119             "java.lang.Integer", "java.lang.Integer",
120                 "com.liferay.portal.kernel.util.OrderByComparator"
121             });
122     public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
123             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
124             FINDER_CLASS_NAME_LIST, "countByGroupId",
125             new String[] { Long.class.getName() });
126     public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
127             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
128             FINDER_CLASS_NAME_LIST, "findByCompanyId",
129             new String[] { Long.class.getName() });
130     public static final FinderPath FINDER_PATH_FIND_BY_OBC_COMPANYID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
131             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
132             FINDER_CLASS_NAME_LIST, "findByCompanyId",
133             new String[] {
134                 Long.class.getName(),
135                 
136             "java.lang.Integer", "java.lang.Integer",
137                 "com.liferay.portal.kernel.util.OrderByComparator"
138             });
139     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
140             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
141             FINDER_CLASS_NAME_LIST, "countByCompanyId",
142             new String[] { Long.class.getName() });
143     public static final FinderPath FINDER_PATH_FIND_BY_SMALLIMAGEID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
144             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
145             FINDER_CLASS_NAME_LIST, "findBySmallImageId",
146             new String[] { Long.class.getName() });
147     public static final FinderPath FINDER_PATH_FIND_BY_OBC_SMALLIMAGEID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
148             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
149             FINDER_CLASS_NAME_LIST, "findBySmallImageId",
150             new String[] {
151                 Long.class.getName(),
152                 
153             "java.lang.Integer", "java.lang.Integer",
154                 "com.liferay.portal.kernel.util.OrderByComparator"
155             });
156     public static final FinderPath FINDER_PATH_COUNT_BY_SMALLIMAGEID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
157             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
158             FINDER_CLASS_NAME_LIST, "countBySmallImageId",
159             new String[] { Long.class.getName() });
160     public static final FinderPath FINDER_PATH_FIND_BY_R_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
161             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
162             FINDER_CLASS_NAME_LIST, "findByR_S",
163             new String[] { Long.class.getName(), Integer.class.getName() });
164     public static final FinderPath FINDER_PATH_FIND_BY_OBC_R_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
165             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
166             FINDER_CLASS_NAME_LIST, "findByR_S",
167             new String[] {
168                 Long.class.getName(), Integer.class.getName(),
169                 
170             "java.lang.Integer", "java.lang.Integer",
171                 "com.liferay.portal.kernel.util.OrderByComparator"
172             });
173     public static final FinderPath FINDER_PATH_COUNT_BY_R_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
174             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
175             FINDER_CLASS_NAME_LIST, "countByR_S",
176             new String[] { Long.class.getName(), Integer.class.getName() });
177     public static final FinderPath FINDER_PATH_FIND_BY_G_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
178             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
179             FINDER_CLASS_NAME_LIST, "findByG_A",
180             new String[] { Long.class.getName(), String.class.getName() });
181     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
182             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
183             FINDER_CLASS_NAME_LIST, "findByG_A",
184             new String[] {
185                 Long.class.getName(), String.class.getName(),
186                 
187             "java.lang.Integer", "java.lang.Integer",
188                 "com.liferay.portal.kernel.util.OrderByComparator"
189             });
190     public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
191             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
192             FINDER_CLASS_NAME_LIST, "countByG_A",
193             new String[] { Long.class.getName(), String.class.getName() });
194     public static final FinderPath FINDER_PATH_FIND_BY_G_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
195             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
196             FINDER_CLASS_NAME_LIST, "findByG_S",
197             new String[] { Long.class.getName(), String.class.getName() });
198     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
199             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
200             FINDER_CLASS_NAME_LIST, "findByG_S",
201             new String[] {
202                 Long.class.getName(), String.class.getName(),
203                 
204             "java.lang.Integer", "java.lang.Integer",
205                 "com.liferay.portal.kernel.util.OrderByComparator"
206             });
207     public static final FinderPath FINDER_PATH_COUNT_BY_G_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
208             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
209             FINDER_CLASS_NAME_LIST, "countByG_S",
210             new String[] { Long.class.getName(), String.class.getName() });
211     public static final FinderPath FINDER_PATH_FIND_BY_G_T = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
212             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
213             FINDER_CLASS_NAME_LIST, "findByG_T",
214             new String[] { Long.class.getName(), String.class.getName() });
215     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_T = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
216             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
217             FINDER_CLASS_NAME_LIST, "findByG_T",
218             new String[] {
219                 Long.class.getName(), String.class.getName(),
220                 
221             "java.lang.Integer", "java.lang.Integer",
222                 "com.liferay.portal.kernel.util.OrderByComparator"
223             });
224     public static final FinderPath FINDER_PATH_COUNT_BY_G_T = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
225             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
226             FINDER_CLASS_NAME_LIST, "countByG_T",
227             new String[] { Long.class.getName(), String.class.getName() });
228     public static final FinderPath FINDER_PATH_FIND_BY_G_UT = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
229             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
230             FINDER_CLASS_NAME_LIST, "findByG_UT",
231             new String[] { Long.class.getName(), String.class.getName() });
232     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_UT = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
233             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
234             FINDER_CLASS_NAME_LIST, "findByG_UT",
235             new String[] {
236                 Long.class.getName(), String.class.getName(),
237                 
238             "java.lang.Integer", "java.lang.Integer",
239                 "com.liferay.portal.kernel.util.OrderByComparator"
240             });
241     public static final FinderPath FINDER_PATH_COUNT_BY_G_UT = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
242             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
243             FINDER_CLASS_NAME_LIST, "countByG_UT",
244             new String[] { Long.class.getName(), String.class.getName() });
245     public static final FinderPath FINDER_PATH_FIND_BY_C_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
246             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
247             FINDER_CLASS_NAME_LIST, "findByC_S",
248             new String[] { Long.class.getName(), Integer.class.getName() });
249     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
250             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
251             FINDER_CLASS_NAME_LIST, "findByC_S",
252             new String[] {
253                 Long.class.getName(), Integer.class.getName(),
254                 
255             "java.lang.Integer", "java.lang.Integer",
256                 "com.liferay.portal.kernel.util.OrderByComparator"
257             });
258     public static final FinderPath FINDER_PATH_COUNT_BY_C_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
259             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
260             FINDER_CLASS_NAME_LIST, "countByC_S",
261             new String[] { Long.class.getName(), Integer.class.getName() });
262     public static final FinderPath FINDER_PATH_FETCH_BY_G_A_V = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
263             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
264             FINDER_CLASS_NAME_ENTITY, "fetchByG_A_V",
265             new String[] {
266                 Long.class.getName(), String.class.getName(),
267                 Double.class.getName()
268             });
269     public static final FinderPath FINDER_PATH_COUNT_BY_G_A_V = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
270             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
271             FINDER_CLASS_NAME_LIST, "countByG_A_V",
272             new String[] {
273                 Long.class.getName(), String.class.getName(),
274                 Double.class.getName()
275             });
276     public static final FinderPath FINDER_PATH_FIND_BY_G_A_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
277             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
278             FINDER_CLASS_NAME_LIST, "findByG_A_S",
279             new String[] {
280                 Long.class.getName(), String.class.getName(),
281                 Integer.class.getName()
282             });
283     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_A_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
284             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
285             FINDER_CLASS_NAME_LIST, "findByG_A_S",
286             new String[] {
287                 Long.class.getName(), String.class.getName(),
288                 Integer.class.getName(),
289                 
290             "java.lang.Integer", "java.lang.Integer",
291                 "com.liferay.portal.kernel.util.OrderByComparator"
292             });
293     public static final FinderPath FINDER_PATH_COUNT_BY_G_A_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
294             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
295             FINDER_CLASS_NAME_LIST, "countByG_A_S",
296             new String[] {
297                 Long.class.getName(), String.class.getName(),
298                 Integer.class.getName()
299             });
300     public static final FinderPath FINDER_PATH_FIND_BY_G_UT_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
301             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
302             FINDER_CLASS_NAME_LIST, "findByG_UT_S",
303             new String[] {
304                 Long.class.getName(), String.class.getName(),
305                 Integer.class.getName()
306             });
307     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_UT_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
308             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
309             FINDER_CLASS_NAME_LIST, "findByG_UT_S",
310             new String[] {
311                 Long.class.getName(), String.class.getName(),
312                 Integer.class.getName(),
313                 
314             "java.lang.Integer", "java.lang.Integer",
315                 "com.liferay.portal.kernel.util.OrderByComparator"
316             });
317     public static final FinderPath FINDER_PATH_COUNT_BY_G_UT_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
318             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
319             FINDER_CLASS_NAME_LIST, "countByG_UT_S",
320             new String[] {
321                 Long.class.getName(), String.class.getName(),
322                 Integer.class.getName()
323             });
324     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
325             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
326             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
327     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
328             JournalArticleModelImpl.FINDER_CACHE_ENABLED,
329             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
330 
331     public void cacheResult(JournalArticle journalArticle) {
332         EntityCacheUtil.putResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
333             JournalArticleImpl.class, journalArticle.getPrimaryKey(),
334             journalArticle);
335 
336         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
337             new Object[] {
338                 journalArticle.getUuid(), new Long(journalArticle.getGroupId())
339             }, journalArticle);
340 
341         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
342             new Object[] {
343                 new Long(journalArticle.getGroupId()),
344                 
345             journalArticle.getArticleId(),
346                 new Double(journalArticle.getVersion())
347             }, journalArticle);
348     }
349 
350     public void cacheResult(List<JournalArticle> journalArticles) {
351         for (JournalArticle journalArticle : journalArticles) {
352             if (EntityCacheUtil.getResult(
353                         JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
354                         JournalArticleImpl.class,
355                         journalArticle.getPrimaryKey(), this) == null) {
356                 cacheResult(journalArticle);
357             }
358         }
359     }
360 
361     public void clearCache() {
362         CacheRegistry.clear(JournalArticleImpl.class.getName());
363         EntityCacheUtil.clearCache(JournalArticleImpl.class.getName());
364         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
365         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
366     }
367 
368     public JournalArticle create(long id) {
369         JournalArticle journalArticle = new JournalArticleImpl();
370 
371         journalArticle.setNew(true);
372         journalArticle.setPrimaryKey(id);
373 
374         String uuid = PortalUUIDUtil.generate();
375 
376         journalArticle.setUuid(uuid);
377 
378         return journalArticle;
379     }
380 
381     public JournalArticle remove(Serializable primaryKey)
382         throws NoSuchModelException, SystemException {
383         return remove(((Long)primaryKey).longValue());
384     }
385 
386     public JournalArticle remove(long id)
387         throws NoSuchArticleException, SystemException {
388         Session session = null;
389 
390         try {
391             session = openSession();
392 
393             JournalArticle journalArticle = (JournalArticle)session.get(JournalArticleImpl.class,
394                     new Long(id));
395 
396             if (journalArticle == null) {
397                 if (_log.isWarnEnabled()) {
398                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + id);
399                 }
400 
401                 throw new NoSuchArticleException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
402                     id);
403             }
404 
405             return remove(journalArticle);
406         }
407         catch (NoSuchArticleException nsee) {
408             throw nsee;
409         }
410         catch (Exception e) {
411             throw processException(e);
412         }
413         finally {
414             closeSession(session);
415         }
416     }
417 
418     public JournalArticle remove(JournalArticle journalArticle)
419         throws SystemException {
420         for (ModelListener<JournalArticle> listener : listeners) {
421             listener.onBeforeRemove(journalArticle);
422         }
423 
424         journalArticle = removeImpl(journalArticle);
425 
426         for (ModelListener<JournalArticle> listener : listeners) {
427             listener.onAfterRemove(journalArticle);
428         }
429 
430         return journalArticle;
431     }
432 
433     protected JournalArticle removeImpl(JournalArticle journalArticle)
434         throws SystemException {
435         journalArticle = toUnwrappedModel(journalArticle);
436 
437         Session session = null;
438 
439         try {
440             session = openSession();
441 
442             if (journalArticle.isCachedModel() || BatchSessionUtil.isEnabled()) {
443                 Object staleObject = session.get(JournalArticleImpl.class,
444                         journalArticle.getPrimaryKeyObj());
445 
446                 if (staleObject != null) {
447                     session.evict(staleObject);
448                 }
449             }
450 
451             session.delete(journalArticle);
452 
453             session.flush();
454         }
455         catch (Exception e) {
456             throw processException(e);
457         }
458         finally {
459             closeSession(session);
460         }
461 
462         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
463 
464         JournalArticleModelImpl journalArticleModelImpl = (JournalArticleModelImpl)journalArticle;
465 
466         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
467             new Object[] {
468                 journalArticleModelImpl.getOriginalUuid(),
469                 new Long(journalArticleModelImpl.getOriginalGroupId())
470             });
471 
472         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V,
473             new Object[] {
474                 new Long(journalArticleModelImpl.getOriginalGroupId()),
475                 
476             journalArticleModelImpl.getOriginalArticleId(),
477                 new Double(journalArticleModelImpl.getOriginalVersion())
478             });
479 
480         EntityCacheUtil.removeResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
481             JournalArticleImpl.class, journalArticle.getPrimaryKey());
482 
483         return journalArticle;
484     }
485 
486     public JournalArticle updateImpl(
487         com.liferay.portlet.journal.model.JournalArticle journalArticle,
488         boolean merge) throws SystemException {
489         journalArticle = toUnwrappedModel(journalArticle);
490 
491         boolean isNew = journalArticle.isNew();
492 
493         JournalArticleModelImpl journalArticleModelImpl = (JournalArticleModelImpl)journalArticle;
494 
495         if (Validator.isNull(journalArticle.getUuid())) {
496             String uuid = PortalUUIDUtil.generate();
497 
498             journalArticle.setUuid(uuid);
499         }
500 
501         Session session = null;
502 
503         try {
504             session = openSession();
505 
506             BatchSessionUtil.update(session, journalArticle, merge);
507 
508             journalArticle.setNew(false);
509         }
510         catch (Exception e) {
511             throw processException(e);
512         }
513         finally {
514             closeSession(session);
515         }
516 
517         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
518 
519         EntityCacheUtil.putResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
520             JournalArticleImpl.class, journalArticle.getPrimaryKey(),
521             journalArticle);
522 
523         if (!isNew &&
524                 (!Validator.equals(journalArticle.getUuid(),
525                     journalArticleModelImpl.getOriginalUuid()) ||
526                 (journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()))) {
527             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
528                 new Object[] {
529                     journalArticleModelImpl.getOriginalUuid(),
530                     new Long(journalArticleModelImpl.getOriginalGroupId())
531                 });
532         }
533 
534         if (isNew ||
535                 (!Validator.equals(journalArticle.getUuid(),
536                     journalArticleModelImpl.getOriginalUuid()) ||
537                 (journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()))) {
538             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
539                 new Object[] {
540                     journalArticle.getUuid(),
541                     new Long(journalArticle.getGroupId())
542                 }, journalArticle);
543         }
544 
545         if (!isNew &&
546                 ((journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()) ||
547                 !Validator.equals(journalArticle.getArticleId(),
548                     journalArticleModelImpl.getOriginalArticleId()) ||
549                 (journalArticle.getVersion() != journalArticleModelImpl.getOriginalVersion()))) {
550             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V,
551                 new Object[] {
552                     new Long(journalArticleModelImpl.getOriginalGroupId()),
553                     
554                 journalArticleModelImpl.getOriginalArticleId(),
555                     new Double(journalArticleModelImpl.getOriginalVersion())
556                 });
557         }
558 
559         if (isNew ||
560                 ((journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()) ||
561                 !Validator.equals(journalArticle.getArticleId(),
562                     journalArticleModelImpl.getOriginalArticleId()) ||
563                 (journalArticle.getVersion() != journalArticleModelImpl.getOriginalVersion()))) {
564             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
565                 new Object[] {
566                     new Long(journalArticle.getGroupId()),
567                     
568                 journalArticle.getArticleId(),
569                     new Double(journalArticle.getVersion())
570                 }, journalArticle);
571         }
572 
573         return journalArticle;
574     }
575 
576     protected JournalArticle toUnwrappedModel(JournalArticle journalArticle) {
577         if (journalArticle instanceof JournalArticleImpl) {
578             return journalArticle;
579         }
580 
581         JournalArticleImpl journalArticleImpl = new JournalArticleImpl();
582 
583         journalArticleImpl.setNew(journalArticle.isNew());
584         journalArticleImpl.setPrimaryKey(journalArticle.getPrimaryKey());
585 
586         journalArticleImpl.setUuid(journalArticle.getUuid());
587         journalArticleImpl.setId(journalArticle.getId());
588         journalArticleImpl.setResourcePrimKey(journalArticle.getResourcePrimKey());
589         journalArticleImpl.setGroupId(journalArticle.getGroupId());
590         journalArticleImpl.setCompanyId(journalArticle.getCompanyId());
591         journalArticleImpl.setUserId(journalArticle.getUserId());
592         journalArticleImpl.setUserName(journalArticle.getUserName());
593         journalArticleImpl.setCreateDate(journalArticle.getCreateDate());
594         journalArticleImpl.setModifiedDate(journalArticle.getModifiedDate());
595         journalArticleImpl.setArticleId(journalArticle.getArticleId());
596         journalArticleImpl.setVersion(journalArticle.getVersion());
597         journalArticleImpl.setTitle(journalArticle.getTitle());
598         journalArticleImpl.setUrlTitle(journalArticle.getUrlTitle());
599         journalArticleImpl.setDescription(journalArticle.getDescription());
600         journalArticleImpl.setContent(journalArticle.getContent());
601         journalArticleImpl.setType(journalArticle.getType());
602         journalArticleImpl.setStructureId(journalArticle.getStructureId());
603         journalArticleImpl.setTemplateId(journalArticle.getTemplateId());
604         journalArticleImpl.setDisplayDate(journalArticle.getDisplayDate());
605         journalArticleImpl.setExpirationDate(journalArticle.getExpirationDate());
606         journalArticleImpl.setReviewDate(journalArticle.getReviewDate());
607         journalArticleImpl.setIndexable(journalArticle.isIndexable());
608         journalArticleImpl.setSmallImage(journalArticle.isSmallImage());
609         journalArticleImpl.setSmallImageId(journalArticle.getSmallImageId());
610         journalArticleImpl.setSmallImageURL(journalArticle.getSmallImageURL());
611         journalArticleImpl.setStatus(journalArticle.getStatus());
612         journalArticleImpl.setStatusByUserId(journalArticle.getStatusByUserId());
613         journalArticleImpl.setStatusByUserName(journalArticle.getStatusByUserName());
614         journalArticleImpl.setStatusDate(journalArticle.getStatusDate());
615 
616         return journalArticleImpl;
617     }
618 
619     public JournalArticle findByPrimaryKey(Serializable primaryKey)
620         throws NoSuchModelException, SystemException {
621         return findByPrimaryKey(((Long)primaryKey).longValue());
622     }
623 
624     public JournalArticle findByPrimaryKey(long id)
625         throws NoSuchArticleException, SystemException {
626         JournalArticle journalArticle = fetchByPrimaryKey(id);
627 
628         if (journalArticle == null) {
629             if (_log.isWarnEnabled()) {
630                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + id);
631             }
632 
633             throw new NoSuchArticleException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
634                 id);
635         }
636 
637         return journalArticle;
638     }
639 
640     public JournalArticle fetchByPrimaryKey(Serializable primaryKey)
641         throws SystemException {
642         return fetchByPrimaryKey(((Long)primaryKey).longValue());
643     }
644 
645     public JournalArticle fetchByPrimaryKey(long id) throws SystemException {
646         JournalArticle journalArticle = (JournalArticle)EntityCacheUtil.getResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
647                 JournalArticleImpl.class, id, this);
648 
649         if (journalArticle == null) {
650             Session session = null;
651 
652             try {
653                 session = openSession();
654 
655                 journalArticle = (JournalArticle)session.get(JournalArticleImpl.class,
656                         new Long(id));
657             }
658             catch (Exception e) {
659                 throw processException(e);
660             }
661             finally {
662                 if (journalArticle != null) {
663                     cacheResult(journalArticle);
664                 }
665 
666                 closeSession(session);
667             }
668         }
669 
670         return journalArticle;
671     }
672 
673     public List<JournalArticle> findByUuid(String uuid)
674         throws SystemException {
675         Object[] finderArgs = new Object[] { uuid };
676 
677         List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
678                 finderArgs, this);
679 
680         if (list == null) {
681             Session session = null;
682 
683             try {
684                 session = openSession();
685 
686                 StringBundler query = new StringBundler(3);
687 
688                 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
689 
690                 if (uuid == null) {
691                     query.append(_FINDER_COLUMN_UUID_UUID_1);
692                 }
693                 else {
694                     if (uuid.equals(StringPool.BLANK)) {
695                         query.append(_FINDER_COLUMN_UUID_UUID_3);
696                     }
697                     else {
698                         query.append(_FINDER_COLUMN_UUID_UUID_2);
699                     }
700                 }
701 
702                 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
703 
704                 String sql = query.toString();
705 
706                 Query q = session.createQuery(sql);
707 
708                 QueryPos qPos = QueryPos.getInstance(q);
709 
710                 if (uuid != null) {
711                     qPos.add(uuid);
712                 }
713 
714                 list = q.list();
715             }
716             catch (Exception e) {
717                 throw processException(e);
718             }
719             finally {
720                 if (list == null) {
721                     list = new ArrayList<JournalArticle>();
722                 }
723 
724                 cacheResult(list);
725 
726                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
727                     list);
728 
729                 closeSession(session);
730             }
731         }
732 
733         return list;
734     }
735 
736     public List<JournalArticle> findByUuid(String uuid, int start, int end)
737         throws SystemException {
738         return findByUuid(uuid, start, end, null);
739     }
740 
741     public List<JournalArticle> findByUuid(String uuid, int start, int end,
742         OrderByComparator orderByComparator) throws SystemException {
743         Object[] finderArgs = new Object[] {
744                 uuid,
745                 
746                 String.valueOf(start), String.valueOf(end),
747                 String.valueOf(orderByComparator)
748             };
749 
750         List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_UUID,
751                 finderArgs, this);
752 
753         if (list == null) {
754             Session session = null;
755 
756             try {
757                 session = openSession();
758 
759                 StringBundler query = null;
760 
761                 if (orderByComparator != null) {
762                     query = new StringBundler(3 +
763                             (orderByComparator.getOrderByFields().length * 3));
764                 }
765                 else {
766                     query = new StringBundler(3);
767                 }
768 
769                 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
770 
771                 if (uuid == null) {
772                     query.append(_FINDER_COLUMN_UUID_UUID_1);
773                 }
774                 else {
775                     if (uuid.equals(StringPool.BLANK)) {
776                         query.append(_FINDER_COLUMN_UUID_UUID_3);
777                     }
778                     else {
779                         query.append(_FINDER_COLUMN_UUID_UUID_2);
780                     }
781                 }
782 
783                 if (orderByComparator != null) {
784                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
785                         orderByComparator);
786                 }
787 
788                 else {
789                     query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
790                 }
791 
792                 String sql = query.toString();
793 
794                 Query q = session.createQuery(sql);
795 
796                 QueryPos qPos = QueryPos.getInstance(q);
797 
798                 if (uuid != null) {
799                     qPos.add(uuid);
800                 }
801 
802                 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
803                         start, end);
804             }
805             catch (Exception e) {
806                 throw processException(e);
807             }
808             finally {
809                 if (list == null) {
810                     list = new ArrayList<JournalArticle>();
811                 }
812 
813                 cacheResult(list);
814 
815                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_UUID,
816                     finderArgs, list);
817 
818                 closeSession(session);
819             }
820         }
821 
822         return list;
823     }
824 
825     public JournalArticle findByUuid_First(String uuid,
826         OrderByComparator orderByComparator)
827         throws NoSuchArticleException, SystemException {
828         List<JournalArticle> list = findByUuid(uuid, 0, 1, orderByComparator);
829 
830         if (list.isEmpty()) {
831             StringBundler msg = new StringBundler(4);
832 
833             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
834 
835             msg.append("uuid=");
836             msg.append(uuid);
837 
838             msg.append(StringPool.CLOSE_CURLY_BRACE);
839 
840             throw new NoSuchArticleException(msg.toString());
841         }
842         else {
843             return list.get(0);
844         }
845     }
846 
847     public JournalArticle findByUuid_Last(String uuid,
848         OrderByComparator orderByComparator)
849         throws NoSuchArticleException, SystemException {
850         int count = countByUuid(uuid);
851 
852         List<JournalArticle> list = findByUuid(uuid, count - 1, count,
853                 orderByComparator);
854 
855         if (list.isEmpty()) {
856             StringBundler msg = new StringBundler(4);
857 
858             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
859 
860             msg.append("uuid=");
861             msg.append(uuid);
862 
863             msg.append(StringPool.CLOSE_CURLY_BRACE);
864 
865             throw new NoSuchArticleException(msg.toString());
866         }
867         else {
868             return list.get(0);
869         }
870     }
871 
872     public JournalArticle[] findByUuid_PrevAndNext(long id, String uuid,
873         OrderByComparator orderByComparator)
874         throws NoSuchArticleException, SystemException {
875         JournalArticle journalArticle = findByPrimaryKey(id);
876 
877         int count = countByUuid(uuid);
878 
879         Session session = null;
880 
881         try {
882             session = openSession();
883 
884             StringBundler query = null;
885 
886             if (orderByComparator != null) {
887                 query = new StringBundler(3 +
888                         (orderByComparator.getOrderByFields().length * 3));
889             }
890             else {
891                 query = new StringBundler(3);
892             }
893 
894             query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
895 
896             if (uuid == null) {
897                 query.append(_FINDER_COLUMN_UUID_UUID_1);
898             }
899             else {
900                 if (uuid.equals(StringPool.BLANK)) {
901                     query.append(_FINDER_COLUMN_UUID_UUID_3);
902                 }
903                 else {
904                     query.append(_FINDER_COLUMN_UUID_UUID_2);
905                 }
906             }
907 
908             if (orderByComparator != null) {
909                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
910                     orderByComparator);
911             }
912 
913             else {
914                 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
915             }
916 
917             String sql = query.toString();
918 
919             Query q = session.createQuery(sql);
920 
921             QueryPos qPos = QueryPos.getInstance(q);
922 
923             if (uuid != null) {
924                 qPos.add(uuid);
925             }
926 
927             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
928                     orderByComparator, journalArticle);
929 
930             JournalArticle[] array = new JournalArticleImpl[3];
931 
932             array[0] = (JournalArticle)objArray[0];
933             array[1] = (JournalArticle)objArray[1];
934             array[2] = (JournalArticle)objArray[2];
935 
936             return array;
937         }
938         catch (Exception e) {
939             throw processException(e);
940         }
941         finally {
942             closeSession(session);
943         }
944     }
945 
946     public JournalArticle findByUUID_G(String uuid, long groupId)
947         throws NoSuchArticleException, SystemException {
948         JournalArticle journalArticle = fetchByUUID_G(uuid, groupId);
949 
950         if (journalArticle == null) {
951             StringBundler msg = new StringBundler(6);
952 
953             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
954 
955             msg.append("uuid=");
956             msg.append(uuid);
957 
958             msg.append(", groupId=");
959             msg.append(groupId);
960 
961             msg.append(StringPool.CLOSE_CURLY_BRACE);
962 
963             if (_log.isWarnEnabled()) {
964                 _log.warn(msg.toString());
965             }
966 
967             throw new NoSuchArticleException(msg.toString());
968         }
969 
970         return journalArticle;
971     }
972 
973     public JournalArticle fetchByUUID_G(String uuid, long groupId)
974         throws SystemException {
975         return fetchByUUID_G(uuid, groupId, true);
976     }
977 
978     public JournalArticle fetchByUUID_G(String uuid, long groupId,
979         boolean retrieveFromCache) throws SystemException {
980         Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
981 
982         Object result = null;
983 
984         if (retrieveFromCache) {
985             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
986                     finderArgs, this);
987         }
988 
989         if (result == null) {
990             Session session = null;
991 
992             try {
993                 session = openSession();
994 
995                 StringBundler query = new StringBundler(4);
996 
997                 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
998 
999                 if (uuid == null) {
1000                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1001                }
1002                else {
1003                    if (uuid.equals(StringPool.BLANK)) {
1004                        query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1005                    }
1006                    else {
1007                        query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1008                    }
1009                }
1010
1011                query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1012
1013                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1014
1015                String sql = query.toString();
1016
1017                Query q = session.createQuery(sql);
1018
1019                QueryPos qPos = QueryPos.getInstance(q);
1020
1021                if (uuid != null) {
1022                    qPos.add(uuid);
1023                }
1024
1025                qPos.add(groupId);
1026
1027                List<JournalArticle> list = q.list();
1028
1029                result = list;
1030
1031                JournalArticle journalArticle = null;
1032
1033                if (list.isEmpty()) {
1034                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1035                        finderArgs, list);
1036                }
1037                else {
1038                    journalArticle = list.get(0);
1039
1040                    cacheResult(journalArticle);
1041
1042                    if ((journalArticle.getUuid() == null) ||
1043                            !journalArticle.getUuid().equals(uuid) ||
1044                            (journalArticle.getGroupId() != groupId)) {
1045                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1046                            finderArgs, journalArticle);
1047                    }
1048                }
1049
1050                return journalArticle;
1051            }
1052            catch (Exception e) {
1053                throw processException(e);
1054            }
1055            finally {
1056                if (result == null) {
1057                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1058                        finderArgs, new ArrayList<JournalArticle>());
1059                }
1060
1061                closeSession(session);
1062            }
1063        }
1064        else {
1065            if (result instanceof List<?>) {
1066                return null;
1067            }
1068            else {
1069                return (JournalArticle)result;
1070            }
1071        }
1072    }
1073
1074    public List<JournalArticle> findByGroupId(long groupId)
1075        throws SystemException {
1076        Object[] finderArgs = new Object[] { new Long(groupId) };
1077
1078        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1079                finderArgs, this);
1080
1081        if (list == null) {
1082            Session session = null;
1083
1084            try {
1085                session = openSession();
1086
1087                StringBundler query = new StringBundler(3);
1088
1089                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1090
1091                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1092
1093                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1094
1095                String sql = query.toString();
1096
1097                Query q = session.createQuery(sql);
1098
1099                QueryPos qPos = QueryPos.getInstance(q);
1100
1101                qPos.add(groupId);
1102
1103                list = q.list();
1104            }
1105            catch (Exception e) {
1106                throw processException(e);
1107            }
1108            finally {
1109                if (list == null) {
1110                    list = new ArrayList<JournalArticle>();
1111                }
1112
1113                cacheResult(list);
1114
1115                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1116                    finderArgs, list);
1117
1118                closeSession(session);
1119            }
1120        }
1121
1122        return list;
1123    }
1124
1125    public List<JournalArticle> findByGroupId(long groupId, int start, int end)
1126        throws SystemException {
1127        return findByGroupId(groupId, start, end, null);
1128    }
1129
1130    public List<JournalArticle> findByGroupId(long groupId, int start, int end,
1131        OrderByComparator orderByComparator) throws SystemException {
1132        Object[] finderArgs = new Object[] {
1133                new Long(groupId),
1134                
1135                String.valueOf(start), String.valueOf(end),
1136                String.valueOf(orderByComparator)
1137            };
1138
1139        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
1140                finderArgs, this);
1141
1142        if (list == null) {
1143            Session session = null;
1144
1145            try {
1146                session = openSession();
1147
1148                StringBundler query = null;
1149
1150                if (orderByComparator != null) {
1151                    query = new StringBundler(3 +
1152                            (orderByComparator.getOrderByFields().length * 3));
1153                }
1154                else {
1155                    query = new StringBundler(3);
1156                }
1157
1158                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1159
1160                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1161
1162                if (orderByComparator != null) {
1163                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1164                        orderByComparator);
1165                }
1166
1167                else {
1168                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1169                }
1170
1171                String sql = query.toString();
1172
1173                Query q = session.createQuery(sql);
1174
1175                QueryPos qPos = QueryPos.getInstance(q);
1176
1177                qPos.add(groupId);
1178
1179                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1180                        start, end);
1181            }
1182            catch (Exception e) {
1183                throw processException(e);
1184            }
1185            finally {
1186                if (list == null) {
1187                    list = new ArrayList<JournalArticle>();
1188                }
1189
1190                cacheResult(list);
1191
1192                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
1193                    finderArgs, list);
1194
1195                closeSession(session);
1196            }
1197        }
1198
1199        return list;
1200    }
1201
1202    public JournalArticle findByGroupId_First(long groupId,
1203        OrderByComparator orderByComparator)
1204        throws NoSuchArticleException, SystemException {
1205        List<JournalArticle> list = findByGroupId(groupId, 0, 1,
1206                orderByComparator);
1207
1208        if (list.isEmpty()) {
1209            StringBundler msg = new StringBundler(4);
1210
1211            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1212
1213            msg.append("groupId=");
1214            msg.append(groupId);
1215
1216            msg.append(StringPool.CLOSE_CURLY_BRACE);
1217
1218            throw new NoSuchArticleException(msg.toString());
1219        }
1220        else {
1221            return list.get(0);
1222        }
1223    }
1224
1225    public JournalArticle findByGroupId_Last(long groupId,
1226        OrderByComparator orderByComparator)
1227        throws NoSuchArticleException, SystemException {
1228        int count = countByGroupId(groupId);
1229
1230        List<JournalArticle> list = findByGroupId(groupId, count - 1, count,
1231                orderByComparator);
1232
1233        if (list.isEmpty()) {
1234            StringBundler msg = new StringBundler(4);
1235
1236            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1237
1238            msg.append("groupId=");
1239            msg.append(groupId);
1240
1241            msg.append(StringPool.CLOSE_CURLY_BRACE);
1242
1243            throw new NoSuchArticleException(msg.toString());
1244        }
1245        else {
1246            return list.get(0);
1247        }
1248    }
1249
1250    public JournalArticle[] findByGroupId_PrevAndNext(long id, long groupId,
1251        OrderByComparator orderByComparator)
1252        throws NoSuchArticleException, SystemException {
1253        JournalArticle journalArticle = findByPrimaryKey(id);
1254
1255        int count = countByGroupId(groupId);
1256
1257        Session session = null;
1258
1259        try {
1260            session = openSession();
1261
1262            StringBundler query = null;
1263
1264            if (orderByComparator != null) {
1265                query = new StringBundler(3 +
1266                        (orderByComparator.getOrderByFields().length * 3));
1267            }
1268            else {
1269                query = new StringBundler(3);
1270            }
1271
1272            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1273
1274            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1275
1276            if (orderByComparator != null) {
1277                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1278                    orderByComparator);
1279            }
1280
1281            else {
1282                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1283            }
1284
1285            String sql = query.toString();
1286
1287            Query q = session.createQuery(sql);
1288
1289            QueryPos qPos = QueryPos.getInstance(q);
1290
1291            qPos.add(groupId);
1292
1293            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1294                    orderByComparator, journalArticle);
1295
1296            JournalArticle[] array = new JournalArticleImpl[3];
1297
1298            array[0] = (JournalArticle)objArray[0];
1299            array[1] = (JournalArticle)objArray[1];
1300            array[2] = (JournalArticle)objArray[2];
1301
1302            return array;
1303        }
1304        catch (Exception e) {
1305            throw processException(e);
1306        }
1307        finally {
1308            closeSession(session);
1309        }
1310    }
1311
1312    public List<JournalArticle> findByCompanyId(long companyId)
1313        throws SystemException {
1314        Object[] finderArgs = new Object[] { new Long(companyId) };
1315
1316        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1317                finderArgs, this);
1318
1319        if (list == null) {
1320            Session session = null;
1321
1322            try {
1323                session = openSession();
1324
1325                StringBundler query = new StringBundler(3);
1326
1327                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1328
1329                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1330
1331                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1332
1333                String sql = query.toString();
1334
1335                Query q = session.createQuery(sql);
1336
1337                QueryPos qPos = QueryPos.getInstance(q);
1338
1339                qPos.add(companyId);
1340
1341                list = q.list();
1342            }
1343            catch (Exception e) {
1344                throw processException(e);
1345            }
1346            finally {
1347                if (list == null) {
1348                    list = new ArrayList<JournalArticle>();
1349                }
1350
1351                cacheResult(list);
1352
1353                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1354                    finderArgs, list);
1355
1356                closeSession(session);
1357            }
1358        }
1359
1360        return list;
1361    }
1362
1363    public List<JournalArticle> findByCompanyId(long companyId, int start,
1364        int end) throws SystemException {
1365        return findByCompanyId(companyId, start, end, null);
1366    }
1367
1368    public List<JournalArticle> findByCompanyId(long companyId, int start,
1369        int end, OrderByComparator orderByComparator) throws SystemException {
1370        Object[] finderArgs = new Object[] {
1371                new Long(companyId),
1372                
1373                String.valueOf(start), String.valueOf(end),
1374                String.valueOf(orderByComparator)
1375            };
1376
1377        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1378                finderArgs, this);
1379
1380        if (list == null) {
1381            Session session = null;
1382
1383            try {
1384                session = openSession();
1385
1386                StringBundler query = null;
1387
1388                if (orderByComparator != null) {
1389                    query = new StringBundler(3 +
1390                            (orderByComparator.getOrderByFields().length * 3));
1391                }
1392                else {
1393                    query = new StringBundler(3);
1394                }
1395
1396                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1397
1398                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1399
1400                if (orderByComparator != null) {
1401                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1402                        orderByComparator);
1403                }
1404
1405                else {
1406                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1407                }
1408
1409                String sql = query.toString();
1410
1411                Query q = session.createQuery(sql);
1412
1413                QueryPos qPos = QueryPos.getInstance(q);
1414
1415                qPos.add(companyId);
1416
1417                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1418                        start, end);
1419            }
1420            catch (Exception e) {
1421                throw processException(e);
1422            }
1423            finally {
1424                if (list == null) {
1425                    list = new ArrayList<JournalArticle>();
1426                }
1427
1428                cacheResult(list);
1429
1430                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1431                    finderArgs, list);
1432
1433                closeSession(session);
1434            }
1435        }
1436
1437        return list;
1438    }
1439
1440    public JournalArticle findByCompanyId_First(long companyId,
1441        OrderByComparator orderByComparator)
1442        throws NoSuchArticleException, SystemException {
1443        List<JournalArticle> list = findByCompanyId(companyId, 0, 1,
1444                orderByComparator);
1445
1446        if (list.isEmpty()) {
1447            StringBundler msg = new StringBundler(4);
1448
1449            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1450
1451            msg.append("companyId=");
1452            msg.append(companyId);
1453
1454            msg.append(StringPool.CLOSE_CURLY_BRACE);
1455
1456            throw new NoSuchArticleException(msg.toString());
1457        }
1458        else {
1459            return list.get(0);
1460        }
1461    }
1462
1463    public JournalArticle findByCompanyId_Last(long companyId,
1464        OrderByComparator orderByComparator)
1465        throws NoSuchArticleException, SystemException {
1466        int count = countByCompanyId(companyId);
1467
1468        List<JournalArticle> list = findByCompanyId(companyId, count - 1,
1469                count, orderByComparator);
1470
1471        if (list.isEmpty()) {
1472            StringBundler msg = new StringBundler(4);
1473
1474            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1475
1476            msg.append("companyId=");
1477            msg.append(companyId);
1478
1479            msg.append(StringPool.CLOSE_CURLY_BRACE);
1480
1481            throw new NoSuchArticleException(msg.toString());
1482        }
1483        else {
1484            return list.get(0);
1485        }
1486    }
1487
1488    public JournalArticle[] findByCompanyId_PrevAndNext(long id,
1489        long companyId, OrderByComparator orderByComparator)
1490        throws NoSuchArticleException, SystemException {
1491        JournalArticle journalArticle = findByPrimaryKey(id);
1492
1493        int count = countByCompanyId(companyId);
1494
1495        Session session = null;
1496
1497        try {
1498            session = openSession();
1499
1500            StringBundler query = null;
1501
1502            if (orderByComparator != null) {
1503                query = new StringBundler(3 +
1504                        (orderByComparator.getOrderByFields().length * 3));
1505            }
1506            else {
1507                query = new StringBundler(3);
1508            }
1509
1510            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1511
1512            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1513
1514            if (orderByComparator != null) {
1515                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1516                    orderByComparator);
1517            }
1518
1519            else {
1520                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1521            }
1522
1523            String sql = query.toString();
1524
1525            Query q = session.createQuery(sql);
1526
1527            QueryPos qPos = QueryPos.getInstance(q);
1528
1529            qPos.add(companyId);
1530
1531            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1532                    orderByComparator, journalArticle);
1533
1534            JournalArticle[] array = new JournalArticleImpl[3];
1535
1536            array[0] = (JournalArticle)objArray[0];
1537            array[1] = (JournalArticle)objArray[1];
1538            array[2] = (JournalArticle)objArray[2];
1539
1540            return array;
1541        }
1542        catch (Exception e) {
1543            throw processException(e);
1544        }
1545        finally {
1546            closeSession(session);
1547        }
1548    }
1549
1550    public List<JournalArticle> findBySmallImageId(long smallImageId)
1551        throws SystemException {
1552        Object[] finderArgs = new Object[] { new Long(smallImageId) };
1553
1554        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_SMALLIMAGEID,
1555                finderArgs, this);
1556
1557        if (list == null) {
1558            Session session = null;
1559
1560            try {
1561                session = openSession();
1562
1563                StringBundler query = new StringBundler(3);
1564
1565                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1566
1567                query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
1568
1569                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1570
1571                String sql = query.toString();
1572
1573                Query q = session.createQuery(sql);
1574
1575                QueryPos qPos = QueryPos.getInstance(q);
1576
1577                qPos.add(smallImageId);
1578
1579                list = q.list();
1580            }
1581            catch (Exception e) {
1582                throw processException(e);
1583            }
1584            finally {
1585                if (list == null) {
1586                    list = new ArrayList<JournalArticle>();
1587                }
1588
1589                cacheResult(list);
1590
1591                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_SMALLIMAGEID,
1592                    finderArgs, list);
1593
1594                closeSession(session);
1595            }
1596        }
1597
1598        return list;
1599    }
1600
1601    public List<JournalArticle> findBySmallImageId(long smallImageId,
1602        int start, int end) throws SystemException {
1603        return findBySmallImageId(smallImageId, start, end, null);
1604    }
1605
1606    public List<JournalArticle> findBySmallImageId(long smallImageId,
1607        int start, int end, OrderByComparator orderByComparator)
1608        throws SystemException {
1609        Object[] finderArgs = new Object[] {
1610                new Long(smallImageId),
1611                
1612                String.valueOf(start), String.valueOf(end),
1613                String.valueOf(orderByComparator)
1614            };
1615
1616        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_SMALLIMAGEID,
1617                finderArgs, this);
1618
1619        if (list == null) {
1620            Session session = null;
1621
1622            try {
1623                session = openSession();
1624
1625                StringBundler query = null;
1626
1627                if (orderByComparator != null) {
1628                    query = new StringBundler(3 +
1629                            (orderByComparator.getOrderByFields().length * 3));
1630                }
1631                else {
1632                    query = new StringBundler(3);
1633                }
1634
1635                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1636
1637                query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
1638
1639                if (orderByComparator != null) {
1640                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1641                        orderByComparator);
1642                }
1643
1644                else {
1645                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1646                }
1647
1648                String sql = query.toString();
1649
1650                Query q = session.createQuery(sql);
1651
1652                QueryPos qPos = QueryPos.getInstance(q);
1653
1654                qPos.add(smallImageId);
1655
1656                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1657                        start, end);
1658            }
1659            catch (Exception e) {
1660                throw processException(e);
1661            }
1662            finally {
1663                if (list == null) {
1664                    list = new ArrayList<JournalArticle>();
1665                }
1666
1667                cacheResult(list);
1668
1669                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_SMALLIMAGEID,
1670                    finderArgs, list);
1671
1672                closeSession(session);
1673            }
1674        }
1675
1676        return list;
1677    }
1678
1679    public JournalArticle findBySmallImageId_First(long smallImageId,
1680        OrderByComparator orderByComparator)
1681        throws NoSuchArticleException, SystemException {
1682        List<JournalArticle> list = findBySmallImageId(smallImageId, 0, 1,
1683                orderByComparator);
1684
1685        if (list.isEmpty()) {
1686            StringBundler msg = new StringBundler(4);
1687
1688            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1689
1690            msg.append("smallImageId=");
1691            msg.append(smallImageId);
1692
1693            msg.append(StringPool.CLOSE_CURLY_BRACE);
1694
1695            throw new NoSuchArticleException(msg.toString());
1696        }
1697        else {
1698            return list.get(0);
1699        }
1700    }
1701
1702    public JournalArticle findBySmallImageId_Last(long smallImageId,
1703        OrderByComparator orderByComparator)
1704        throws NoSuchArticleException, SystemException {
1705        int count = countBySmallImageId(smallImageId);
1706
1707        List<JournalArticle> list = findBySmallImageId(smallImageId, count - 1,
1708                count, orderByComparator);
1709
1710        if (list.isEmpty()) {
1711            StringBundler msg = new StringBundler(4);
1712
1713            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1714
1715            msg.append("smallImageId=");
1716            msg.append(smallImageId);
1717
1718            msg.append(StringPool.CLOSE_CURLY_BRACE);
1719
1720            throw new NoSuchArticleException(msg.toString());
1721        }
1722        else {
1723            return list.get(0);
1724        }
1725    }
1726
1727    public JournalArticle[] findBySmallImageId_PrevAndNext(long id,
1728        long smallImageId, OrderByComparator orderByComparator)
1729        throws NoSuchArticleException, SystemException {
1730        JournalArticle journalArticle = findByPrimaryKey(id);
1731
1732        int count = countBySmallImageId(smallImageId);
1733
1734        Session session = null;
1735
1736        try {
1737            session = openSession();
1738
1739            StringBundler query = null;
1740
1741            if (orderByComparator != null) {
1742                query = new StringBundler(3 +
1743                        (orderByComparator.getOrderByFields().length * 3));
1744            }
1745            else {
1746                query = new StringBundler(3);
1747            }
1748
1749            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1750
1751            query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
1752
1753            if (orderByComparator != null) {
1754                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1755                    orderByComparator);
1756            }
1757
1758            else {
1759                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1760            }
1761
1762            String sql = query.toString();
1763
1764            Query q = session.createQuery(sql);
1765
1766            QueryPos qPos = QueryPos.getInstance(q);
1767
1768            qPos.add(smallImageId);
1769
1770            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
1771                    orderByComparator, journalArticle);
1772
1773            JournalArticle[] array = new JournalArticleImpl[3];
1774
1775            array[0] = (JournalArticle)objArray[0];
1776            array[1] = (JournalArticle)objArray[1];
1777            array[2] = (JournalArticle)objArray[2];
1778
1779            return array;
1780        }
1781        catch (Exception e) {
1782            throw processException(e);
1783        }
1784        finally {
1785            closeSession(session);
1786        }
1787    }
1788
1789    public List<JournalArticle> findByR_S(long resourcePrimKey, int status)
1790        throws SystemException {
1791        Object[] finderArgs = new Object[] {
1792                new Long(resourcePrimKey), new Integer(status)
1793            };
1794
1795        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_R_S,
1796                finderArgs, this);
1797
1798        if (list == null) {
1799            Session session = null;
1800
1801            try {
1802                session = openSession();
1803
1804                StringBundler query = new StringBundler(4);
1805
1806                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1807
1808                query.append(_FINDER_COLUMN_R_S_RESOURCEPRIMKEY_2);
1809
1810                query.append(_FINDER_COLUMN_R_S_STATUS_2);
1811
1812                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1813
1814                String sql = query.toString();
1815
1816                Query q = session.createQuery(sql);
1817
1818                QueryPos qPos = QueryPos.getInstance(q);
1819
1820                qPos.add(resourcePrimKey);
1821
1822                qPos.add(status);
1823
1824                list = q.list();
1825            }
1826            catch (Exception e) {
1827                throw processException(e);
1828            }
1829            finally {
1830                if (list == null) {
1831                    list = new ArrayList<JournalArticle>();
1832                }
1833
1834                cacheResult(list);
1835
1836                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_R_S, finderArgs,
1837                    list);
1838
1839                closeSession(session);
1840            }
1841        }
1842
1843        return list;
1844    }
1845
1846    public List<JournalArticle> findByR_S(long resourcePrimKey, int status,
1847        int start, int end) throws SystemException {
1848        return findByR_S(resourcePrimKey, status, start, end, null);
1849    }
1850
1851    public List<JournalArticle> findByR_S(long resourcePrimKey, int status,
1852        int start, int end, OrderByComparator orderByComparator)
1853        throws SystemException {
1854        Object[] finderArgs = new Object[] {
1855                new Long(resourcePrimKey), new Integer(status),
1856                
1857                String.valueOf(start), String.valueOf(end),
1858                String.valueOf(orderByComparator)
1859            };
1860
1861        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_R_S,
1862                finderArgs, this);
1863
1864        if (list == null) {
1865            Session session = null;
1866
1867            try {
1868                session = openSession();
1869
1870                StringBundler query = null;
1871
1872                if (orderByComparator != null) {
1873                    query = new StringBundler(4 +
1874                            (orderByComparator.getOrderByFields().length * 3));
1875                }
1876                else {
1877                    query = new StringBundler(4);
1878                }
1879
1880                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1881
1882                query.append(_FINDER_COLUMN_R_S_RESOURCEPRIMKEY_2);
1883
1884                query.append(_FINDER_COLUMN_R_S_STATUS_2);
1885
1886                if (orderByComparator != null) {
1887                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1888                        orderByComparator);
1889                }
1890
1891                else {
1892                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1893                }
1894
1895                String sql = query.toString();
1896
1897                Query q = session.createQuery(sql);
1898
1899                QueryPos qPos = QueryPos.getInstance(q);
1900
1901                qPos.add(resourcePrimKey);
1902
1903                qPos.add(status);
1904
1905                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1906                        start, end);
1907            }
1908            catch (Exception e) {
1909                throw processException(e);
1910            }
1911            finally {
1912                if (list == null) {
1913                    list = new ArrayList<JournalArticle>();
1914                }
1915
1916                cacheResult(list);
1917
1918                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_R_S,
1919                    finderArgs, list);
1920
1921                closeSession(session);
1922            }
1923        }
1924
1925        return list;
1926    }
1927
1928    public JournalArticle findByR_S_First(long resourcePrimKey, int status,
1929        OrderByComparator orderByComparator)
1930        throws NoSuchArticleException, SystemException {
1931        List<JournalArticle> list = findByR_S(resourcePrimKey, status, 0, 1,
1932                orderByComparator);
1933
1934        if (list.isEmpty()) {
1935            StringBundler msg = new StringBundler(6);
1936
1937            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1938
1939            msg.append("resourcePrimKey=");
1940            msg.append(resourcePrimKey);
1941
1942            msg.append(", status=");
1943            msg.append(status);
1944
1945            msg.append(StringPool.CLOSE_CURLY_BRACE);
1946
1947            throw new NoSuchArticleException(msg.toString());
1948        }
1949        else {
1950            return list.get(0);
1951        }
1952    }
1953
1954    public JournalArticle findByR_S_Last(long resourcePrimKey, int status,
1955        OrderByComparator orderByComparator)
1956        throws NoSuchArticleException, SystemException {
1957        int count = countByR_S(resourcePrimKey, status);
1958
1959        List<JournalArticle> list = findByR_S(resourcePrimKey, status,
1960                count - 1, count, orderByComparator);
1961
1962        if (list.isEmpty()) {
1963            StringBundler msg = new StringBundler(6);
1964
1965            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1966
1967            msg.append("resourcePrimKey=");
1968            msg.append(resourcePrimKey);
1969
1970            msg.append(", status=");
1971            msg.append(status);
1972
1973            msg.append(StringPool.CLOSE_CURLY_BRACE);
1974
1975            throw new NoSuchArticleException(msg.toString());
1976        }
1977        else {
1978            return list.get(0);
1979        }
1980    }
1981
1982    public JournalArticle[] findByR_S_PrevAndNext(long id,
1983        long resourcePrimKey, int status, OrderByComparator orderByComparator)
1984        throws NoSuchArticleException, SystemException {
1985        JournalArticle journalArticle = findByPrimaryKey(id);
1986
1987        int count = countByR_S(resourcePrimKey, status);
1988
1989        Session session = null;
1990
1991        try {
1992            session = openSession();
1993
1994            StringBundler query = null;
1995
1996            if (orderByComparator != null) {
1997                query = new StringBundler(4 +
1998                        (orderByComparator.getOrderByFields().length * 3));
1999            }
2000            else {
2001                query = new StringBundler(4);
2002            }
2003
2004            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2005
2006            query.append(_FINDER_COLUMN_R_S_RESOURCEPRIMKEY_2);
2007
2008            query.append(_FINDER_COLUMN_R_S_STATUS_2);
2009
2010            if (orderByComparator != null) {
2011                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2012                    orderByComparator);
2013            }
2014
2015            else {
2016                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2017            }
2018
2019            String sql = query.toString();
2020
2021            Query q = session.createQuery(sql);
2022
2023            QueryPos qPos = QueryPos.getInstance(q);
2024
2025            qPos.add(resourcePrimKey);
2026
2027            qPos.add(status);
2028
2029            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
2030                    orderByComparator, journalArticle);
2031
2032            JournalArticle[] array = new JournalArticleImpl[3];
2033
2034            array[0] = (JournalArticle)objArray[0];
2035            array[1] = (JournalArticle)objArray[1];
2036            array[2] = (JournalArticle)objArray[2];
2037
2038            return array;
2039        }
2040        catch (Exception e) {
2041            throw processException(e);
2042        }
2043        finally {
2044            closeSession(session);
2045        }
2046    }
2047
2048    public List<JournalArticle> findByG_A(long groupId, String articleId)
2049        throws SystemException {
2050        Object[] finderArgs = new Object[] { new Long(groupId), articleId };
2051
2052        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A,
2053                finderArgs, this);
2054
2055        if (list == null) {
2056            Session session = null;
2057
2058            try {
2059                session = openSession();
2060
2061                StringBundler query = new StringBundler(4);
2062
2063                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2064
2065                query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2066
2067                if (articleId == null) {
2068                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2069                }
2070                else {
2071                    if (articleId.equals(StringPool.BLANK)) {
2072                        query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2073                    }
2074                    else {
2075                        query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2076                    }
2077                }
2078
2079                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2080
2081                String sql = query.toString();
2082
2083                Query q = session.createQuery(sql);
2084
2085                QueryPos qPos = QueryPos.getInstance(q);
2086
2087                qPos.add(groupId);
2088
2089                if (articleId != null) {
2090                    qPos.add(articleId);
2091                }
2092
2093                list = q.list();
2094            }
2095            catch (Exception e) {
2096                throw processException(e);
2097            }
2098            finally {
2099                if (list == null) {
2100                    list = new ArrayList<JournalArticle>();
2101                }
2102
2103                cacheResult(list);
2104
2105                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A, finderArgs,
2106                    list);
2107
2108                closeSession(session);
2109            }
2110        }
2111
2112        return list;
2113    }
2114
2115    public List<JournalArticle> findByG_A(long groupId, String articleId,
2116        int start, int end) throws SystemException {
2117        return findByG_A(groupId, articleId, start, end, null);
2118    }
2119
2120    public List<JournalArticle> findByG_A(long groupId, String articleId,
2121        int start, int end, OrderByComparator orderByComparator)
2122        throws SystemException {
2123        Object[] finderArgs = new Object[] {
2124                new Long(groupId),
2125                
2126                articleId,
2127                
2128                String.valueOf(start), String.valueOf(end),
2129                String.valueOf(orderByComparator)
2130            };
2131
2132        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_A,
2133                finderArgs, this);
2134
2135        if (list == null) {
2136            Session session = null;
2137
2138            try {
2139                session = openSession();
2140
2141                StringBundler query = null;
2142
2143                if (orderByComparator != null) {
2144                    query = new StringBundler(4 +
2145                            (orderByComparator.getOrderByFields().length * 3));
2146                }
2147                else {
2148                    query = new StringBundler(4);
2149                }
2150
2151                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2152
2153                query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2154
2155                if (articleId == null) {
2156                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2157                }
2158                else {
2159                    if (articleId.equals(StringPool.BLANK)) {
2160                        query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2161                    }
2162                    else {
2163                        query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2164                    }
2165                }
2166
2167                if (orderByComparator != null) {
2168                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2169                        orderByComparator);
2170                }
2171
2172                else {
2173                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2174                }
2175
2176                String sql = query.toString();
2177
2178                Query q = session.createQuery(sql);
2179
2180                QueryPos qPos = QueryPos.getInstance(q);
2181
2182                qPos.add(groupId);
2183
2184                if (articleId != null) {
2185                    qPos.add(articleId);
2186                }
2187
2188                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
2189                        start, end);
2190            }
2191            catch (Exception e) {
2192                throw processException(e);
2193            }
2194            finally {
2195                if (list == null) {
2196                    list = new ArrayList<JournalArticle>();
2197                }
2198
2199                cacheResult(list);
2200
2201                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_A,
2202                    finderArgs, list);
2203
2204                closeSession(session);
2205            }
2206        }
2207
2208        return list;
2209    }
2210
2211    public JournalArticle findByG_A_First(long groupId, String articleId,
2212        OrderByComparator orderByComparator)
2213        throws NoSuchArticleException, SystemException {
2214        List<JournalArticle> list = findByG_A(groupId, articleId, 0, 1,
2215                orderByComparator);
2216
2217        if (list.isEmpty()) {
2218            StringBundler msg = new StringBundler(6);
2219
2220            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2221
2222            msg.append("groupId=");
2223            msg.append(groupId);
2224
2225            msg.append(", articleId=");
2226            msg.append(articleId);
2227
2228            msg.append(StringPool.CLOSE_CURLY_BRACE);
2229
2230            throw new NoSuchArticleException(msg.toString());
2231        }
2232        else {
2233            return list.get(0);
2234        }
2235    }
2236
2237    public JournalArticle findByG_A_Last(long groupId, String articleId,
2238        OrderByComparator orderByComparator)
2239        throws NoSuchArticleException, SystemException {
2240        int count = countByG_A(groupId, articleId);
2241
2242        List<JournalArticle> list = findByG_A(groupId, articleId, count - 1,
2243                count, orderByComparator);
2244
2245        if (list.isEmpty()) {
2246            StringBundler msg = new StringBundler(6);
2247
2248            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2249
2250            msg.append("groupId=");
2251            msg.append(groupId);
2252
2253            msg.append(", articleId=");
2254            msg.append(articleId);
2255
2256            msg.append(StringPool.CLOSE_CURLY_BRACE);
2257
2258            throw new NoSuchArticleException(msg.toString());
2259        }
2260        else {
2261            return list.get(0);
2262        }
2263    }
2264
2265    public JournalArticle[] findByG_A_PrevAndNext(long id, long groupId,
2266        String articleId, OrderByComparator orderByComparator)
2267        throws NoSuchArticleException, SystemException {
2268        JournalArticle journalArticle = findByPrimaryKey(id);
2269
2270        int count = countByG_A(groupId, articleId);
2271
2272        Session session = null;
2273
2274        try {
2275            session = openSession();
2276
2277            StringBundler query = null;
2278
2279            if (orderByComparator != null) {
2280                query = new StringBundler(4 +
2281                        (orderByComparator.getOrderByFields().length * 3));
2282            }
2283            else {
2284                query = new StringBundler(4);
2285            }
2286
2287            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2288
2289            query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2290
2291            if (articleId == null) {
2292                query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2293            }
2294            else {
2295                if (articleId.equals(StringPool.BLANK)) {
2296                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2297                }
2298                else {
2299                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2300                }
2301            }
2302
2303            if (orderByComparator != null) {
2304                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2305                    orderByComparator);
2306            }
2307
2308            else {
2309                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2310            }
2311
2312            String sql = query.toString();
2313
2314            Query q = session.createQuery(sql);
2315
2316            QueryPos qPos = QueryPos.getInstance(q);
2317
2318            qPos.add(groupId);
2319
2320            if (articleId != null) {
2321                qPos.add(articleId);
2322            }
2323
2324            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
2325                    orderByComparator, journalArticle);
2326
2327            JournalArticle[] array = new JournalArticleImpl[3];
2328
2329            array[0] = (JournalArticle)objArray[0];
2330            array[1] = (JournalArticle)objArray[1];
2331            array[2] = (JournalArticle)objArray[2];
2332
2333            return array;
2334        }
2335        catch (Exception e) {
2336            throw processException(e);
2337        }
2338        finally {
2339            closeSession(session);
2340        }
2341    }
2342
2343    public List<JournalArticle> findByG_S(long groupId, String structureId)
2344        throws SystemException {
2345        Object[] finderArgs = new Object[] { new Long(groupId), structureId };
2346
2347        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_S,
2348                finderArgs, this);
2349
2350        if (list == null) {
2351            Session session = null;
2352
2353            try {
2354                session = openSession();
2355
2356                StringBundler query = new StringBundler(4);
2357
2358                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2359
2360                query.append(_FINDER_COLUMN_G_S_GROUPID_2);
2361
2362                if (structureId == null) {
2363                    query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
2364                }
2365                else {
2366                    if (structureId.equals(StringPool.BLANK)) {
2367                        query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
2368                    }
2369                    else {
2370                        query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
2371                    }
2372                }
2373
2374                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2375
2376                String sql = query.toString();
2377
2378                Query q = session.createQuery(sql);
2379
2380                QueryPos qPos = QueryPos.getInstance(q);
2381
2382                qPos.add(groupId);
2383
2384                if (structureId != null) {
2385                    qPos.add(structureId);
2386                }
2387
2388                list = q.list();
2389            }
2390            catch (Exception e) {
2391                throw processException(e);
2392            }
2393            finally {
2394                if (list == null) {
2395                    list = new ArrayList<JournalArticle>();
2396                }
2397
2398                cacheResult(list);
2399
2400                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_S, finderArgs,
2401                    list);
2402
2403                closeSession(session);
2404            }
2405        }
2406
2407        return list;
2408    }
2409
2410    public List<JournalArticle> findByG_S(long groupId, String structureId,
2411        int start, int end) throws SystemException {
2412        return findByG_S(groupId, structureId, start, end, null);
2413    }
2414
2415    public List<JournalArticle> findByG_S(long groupId, String structureId,
2416        int start, int end, OrderByComparator orderByComparator)
2417        throws SystemException {
2418        Object[] finderArgs = new Object[] {
2419                new Long(groupId),
2420                
2421                structureId,
2422                
2423                String.valueOf(start), String.valueOf(end),
2424                String.valueOf(orderByComparator)
2425            };
2426
2427        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_S,
2428                finderArgs, this);
2429
2430        if (list == null) {
2431            Session session = null;
2432
2433            try {
2434                session = openSession();
2435
2436                StringBundler query = null;
2437
2438                if (orderByComparator != null) {
2439                    query = new StringBundler(4 +
2440                            (orderByComparator.getOrderByFields().length * 3));
2441                }
2442                else {
2443                    query = new StringBundler(4);
2444                }
2445
2446                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2447
2448                query.append(_FINDER_COLUMN_G_S_GROUPID_2);
2449
2450                if (structureId == null) {
2451                    query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
2452                }
2453                else {
2454                    if (structureId.equals(StringPool.BLANK)) {
2455                        query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
2456                    }
2457                    else {
2458                        query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
2459                    }
2460                }
2461
2462                if (orderByComparator != null) {
2463                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2464                        orderByComparator);
2465                }
2466
2467                else {
2468                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2469                }
2470
2471                String sql = query.toString();
2472
2473                Query q = session.createQuery(sql);
2474
2475                QueryPos qPos = QueryPos.getInstance(q);
2476
2477                qPos.add(groupId);
2478
2479                if (structureId != null) {
2480                    qPos.add(structureId);
2481                }
2482
2483                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
2484                        start, end);
2485            }
2486            catch (Exception e) {
2487                throw processException(e);
2488            }
2489            finally {
2490                if (list == null) {
2491                    list = new ArrayList<JournalArticle>();
2492                }
2493
2494                cacheResult(list);
2495
2496                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_S,
2497                    finderArgs, list);
2498
2499                closeSession(session);
2500            }
2501        }
2502
2503        return list;
2504    }
2505
2506    public JournalArticle findByG_S_First(long groupId, String structureId,
2507        OrderByComparator orderByComparator)
2508        throws NoSuchArticleException, SystemException {
2509        List<JournalArticle> list = findByG_S(groupId, structureId, 0, 1,
2510                orderByComparator);
2511
2512        if (list.isEmpty()) {
2513            StringBundler msg = new StringBundler(6);
2514
2515            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2516
2517            msg.append("groupId=");
2518            msg.append(groupId);
2519
2520            msg.append(", structureId=");
2521            msg.append(structureId);
2522
2523            msg.append(StringPool.CLOSE_CURLY_BRACE);
2524
2525            throw new NoSuchArticleException(msg.toString());
2526        }
2527        else {
2528            return list.get(0);
2529        }
2530    }
2531
2532    public JournalArticle findByG_S_Last(long groupId, String structureId,
2533        OrderByComparator orderByComparator)
2534        throws NoSuchArticleException, SystemException {
2535        int count = countByG_S(groupId, structureId);
2536
2537        List<JournalArticle> list = findByG_S(groupId, structureId, count - 1,
2538                count, orderByComparator);
2539
2540        if (list.isEmpty()) {
2541            StringBundler msg = new StringBundler(6);
2542
2543            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2544
2545            msg.append("groupId=");
2546            msg.append(groupId);
2547
2548            msg.append(", structureId=");
2549            msg.append(structureId);
2550
2551            msg.append(StringPool.CLOSE_CURLY_BRACE);
2552
2553            throw new NoSuchArticleException(msg.toString());
2554        }
2555        else {
2556            return list.get(0);
2557        }
2558    }
2559
2560    public JournalArticle[] findByG_S_PrevAndNext(long id, long groupId,
2561        String structureId, OrderByComparator orderByComparator)
2562        throws NoSuchArticleException, SystemException {
2563        JournalArticle journalArticle = findByPrimaryKey(id);
2564
2565        int count = countByG_S(groupId, structureId);
2566
2567        Session session = null;
2568
2569        try {
2570            session = openSession();
2571
2572            StringBundler query = null;
2573
2574            if (orderByComparator != null) {
2575                query = new StringBundler(4 +
2576                        (orderByComparator.getOrderByFields().length * 3));
2577            }
2578            else {
2579                query = new StringBundler(4);
2580            }
2581
2582            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2583
2584            query.append(_FINDER_COLUMN_G_S_GROUPID_2);
2585
2586            if (structureId == null) {
2587                query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
2588            }
2589            else {
2590                if (structureId.equals(StringPool.BLANK)) {
2591                    query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
2592                }
2593                else {
2594                    query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
2595                }
2596            }
2597
2598            if (orderByComparator != null) {
2599                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2600                    orderByComparator);
2601            }
2602
2603            else {
2604                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2605            }
2606
2607            String sql = query.toString();
2608
2609            Query q = session.createQuery(sql);
2610
2611            QueryPos qPos = QueryPos.getInstance(q);
2612
2613            qPos.add(groupId);
2614
2615            if (structureId != null) {
2616                qPos.add(structureId);
2617            }
2618
2619            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
2620                    orderByComparator, journalArticle);
2621
2622            JournalArticle[] array = new JournalArticleImpl[3];
2623
2624            array[0] = (JournalArticle)objArray[0];
2625            array[1] = (JournalArticle)objArray[1];
2626            array[2] = (JournalArticle)objArray[2];
2627
2628            return array;
2629        }
2630        catch (Exception e) {
2631            throw processException(e);
2632        }
2633        finally {
2634            closeSession(session);
2635        }
2636    }
2637
2638    public List<JournalArticle> findByG_T(long groupId, String templateId)
2639        throws SystemException {
2640        Object[] finderArgs = new Object[] { new Long(groupId), templateId };
2641
2642        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_T,
2643                finderArgs, this);
2644
2645        if (list == null) {
2646            Session session = null;
2647
2648            try {
2649                session = openSession();
2650
2651                StringBundler query = new StringBundler(4);
2652
2653                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2654
2655                query.append(_FINDER_COLUMN_G_T_GROUPID_2);
2656
2657                if (templateId == null) {
2658                    query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
2659                }
2660                else {
2661                    if (templateId.equals(StringPool.BLANK)) {
2662                        query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
2663                    }
2664                    else {
2665                        query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
2666                    }
2667                }
2668
2669                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2670
2671                String sql = query.toString();
2672
2673                Query q = session.createQuery(sql);
2674
2675                QueryPos qPos = QueryPos.getInstance(q);
2676
2677                qPos.add(groupId);
2678
2679                if (templateId != null) {
2680                    qPos.add(templateId);
2681                }
2682
2683                list = q.list();
2684            }
2685            catch (Exception e) {
2686                throw processException(e);
2687            }
2688            finally {
2689                if (list == null) {
2690                    list = new ArrayList<JournalArticle>();
2691                }
2692
2693                cacheResult(list);
2694
2695                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_T, finderArgs,
2696                    list);
2697
2698                closeSession(session);
2699            }
2700        }
2701
2702        return list;
2703    }
2704
2705    public List<JournalArticle> findByG_T(long groupId, String templateId,
2706        int start, int end) throws SystemException {
2707        return findByG_T(groupId, templateId, start, end, null);
2708    }
2709
2710    public List<JournalArticle> findByG_T(long groupId, String templateId,
2711        int start, int end, OrderByComparator orderByComparator)
2712        throws SystemException {
2713        Object[] finderArgs = new Object[] {
2714                new Long(groupId),
2715                
2716                templateId,
2717                
2718                String.valueOf(start), String.valueOf(end),
2719                String.valueOf(orderByComparator)
2720            };
2721
2722        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_T,
2723                finderArgs, this);
2724
2725        if (list == null) {
2726            Session session = null;
2727
2728            try {
2729                session = openSession();
2730
2731                StringBundler query = null;
2732
2733                if (orderByComparator != null) {
2734                    query = new StringBundler(4 +
2735                            (orderByComparator.getOrderByFields().length * 3));
2736                }
2737                else {
2738                    query = new StringBundler(4);
2739                }
2740
2741                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2742
2743                query.append(_FINDER_COLUMN_G_T_GROUPID_2);
2744
2745                if (templateId == null) {
2746                    query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
2747                }
2748                else {
2749                    if (templateId.equals(StringPool.BLANK)) {
2750                        query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
2751                    }
2752                    else {
2753                        query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
2754                    }
2755                }
2756
2757                if (orderByComparator != null) {
2758                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2759                        orderByComparator);
2760                }
2761
2762                else {
2763                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2764                }
2765
2766                String sql = query.toString();
2767
2768                Query q = session.createQuery(sql);
2769
2770                QueryPos qPos = QueryPos.getInstance(q);
2771
2772                qPos.add(groupId);
2773
2774                if (templateId != null) {
2775                    qPos.add(templateId);
2776                }
2777
2778                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
2779                        start, end);
2780            }
2781            catch (Exception e) {
2782                throw processException(e);
2783            }
2784            finally {
2785                if (list == null) {
2786                    list = new ArrayList<JournalArticle>();
2787                }
2788
2789                cacheResult(list);
2790
2791                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_T,
2792                    finderArgs, list);
2793
2794                closeSession(session);
2795            }
2796        }
2797
2798        return list;
2799    }
2800
2801    public JournalArticle findByG_T_First(long groupId, String templateId,
2802        OrderByComparator orderByComparator)
2803        throws NoSuchArticleException, SystemException {
2804        List<JournalArticle> list = findByG_T(groupId, templateId, 0, 1,
2805                orderByComparator);
2806
2807        if (list.isEmpty()) {
2808            StringBundler msg = new StringBundler(6);
2809
2810            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2811
2812            msg.append("groupId=");
2813            msg.append(groupId);
2814
2815            msg.append(", templateId=");
2816            msg.append(templateId);
2817
2818            msg.append(StringPool.CLOSE_CURLY_BRACE);
2819
2820            throw new NoSuchArticleException(msg.toString());
2821        }
2822        else {
2823            return list.get(0);
2824        }
2825    }
2826
2827    public JournalArticle findByG_T_Last(long groupId, String templateId,
2828        OrderByComparator orderByComparator)
2829        throws NoSuchArticleException, SystemException {
2830        int count = countByG_T(groupId, templateId);
2831
2832        List<JournalArticle> list = findByG_T(groupId, templateId, count - 1,
2833                count, orderByComparator);
2834
2835        if (list.isEmpty()) {
2836            StringBundler msg = new StringBundler(6);
2837
2838            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2839
2840            msg.append("groupId=");
2841            msg.append(groupId);
2842
2843            msg.append(", templateId=");
2844            msg.append(templateId);
2845
2846            msg.append(StringPool.CLOSE_CURLY_BRACE);
2847
2848            throw new NoSuchArticleException(msg.toString());
2849        }
2850        else {
2851            return list.get(0);
2852        }
2853    }
2854
2855    public JournalArticle[] findByG_T_PrevAndNext(long id, long groupId,
2856        String templateId, OrderByComparator orderByComparator)
2857        throws NoSuchArticleException, SystemException {
2858        JournalArticle journalArticle = findByPrimaryKey(id);
2859
2860        int count = countByG_T(groupId, templateId);
2861
2862        Session session = null;
2863
2864        try {
2865            session = openSession();
2866
2867            StringBundler query = null;
2868
2869            if (orderByComparator != null) {
2870                query = new StringBundler(4 +
2871                        (orderByComparator.getOrderByFields().length * 3));
2872            }
2873            else {
2874                query = new StringBundler(4);
2875            }
2876
2877            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2878
2879            query.append(_FINDER_COLUMN_G_T_GROUPID_2);
2880
2881            if (templateId == null) {
2882                query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
2883            }
2884            else {
2885                if (templateId.equals(StringPool.BLANK)) {
2886                    query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
2887                }
2888                else {
2889                    query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
2890                }
2891            }
2892
2893            if (orderByComparator != null) {
2894                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2895                    orderByComparator);
2896            }
2897
2898            else {
2899                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2900            }
2901
2902            String sql = query.toString();
2903
2904            Query q = session.createQuery(sql);
2905
2906            QueryPos qPos = QueryPos.getInstance(q);
2907
2908            qPos.add(groupId);
2909
2910            if (templateId != null) {
2911                qPos.add(templateId);
2912            }
2913
2914            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
2915                    orderByComparator, journalArticle);
2916
2917            JournalArticle[] array = new JournalArticleImpl[3];
2918
2919            array[0] = (JournalArticle)objArray[0];
2920            array[1] = (JournalArticle)objArray[1];
2921            array[2] = (JournalArticle)objArray[2];
2922
2923            return array;
2924        }
2925        catch (Exception e) {
2926            throw processException(e);
2927        }
2928        finally {
2929            closeSession(session);
2930        }
2931    }
2932
2933    public List<JournalArticle> findByG_UT(long groupId, String urlTitle)
2934        throws SystemException {
2935        Object[] finderArgs = new Object[] { new Long(groupId), urlTitle };
2936
2937        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_UT,
2938                finderArgs, this);
2939
2940        if (list == null) {
2941            Session session = null;
2942
2943            try {
2944                session = openSession();
2945
2946                StringBundler query = new StringBundler(4);
2947
2948                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2949
2950                query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
2951
2952                if (urlTitle == null) {
2953                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
2954                }
2955                else {
2956                    if (urlTitle.equals(StringPool.BLANK)) {
2957                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
2958                    }
2959                    else {
2960                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
2961                    }
2962                }
2963
2964                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2965
2966                String sql = query.toString();
2967
2968                Query q = session.createQuery(sql);
2969
2970                QueryPos qPos = QueryPos.getInstance(q);
2971
2972                qPos.add(groupId);
2973
2974                if (urlTitle != null) {
2975                    qPos.add(urlTitle);
2976                }
2977
2978                list = q.list();
2979            }
2980            catch (Exception e) {
2981                throw processException(e);
2982            }
2983            finally {
2984                if (list == null) {
2985                    list = new ArrayList<JournalArticle>();
2986                }
2987
2988                cacheResult(list);
2989
2990                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_UT, finderArgs,
2991                    list);
2992
2993                closeSession(session);
2994            }
2995        }
2996
2997        return list;
2998    }
2999
3000    public List<JournalArticle> findByG_UT(long groupId, String urlTitle,
3001        int start, int end) throws SystemException {
3002        return findByG_UT(groupId, urlTitle, start, end, null);
3003    }
3004
3005    public List<JournalArticle> findByG_UT(long groupId, String urlTitle,
3006        int start, int end, OrderByComparator orderByComparator)
3007        throws SystemException {
3008        Object[] finderArgs = new Object[] {
3009                new Long(groupId),
3010                
3011                urlTitle,
3012                
3013                String.valueOf(start), String.valueOf(end),
3014                String.valueOf(orderByComparator)
3015            };
3016
3017        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_UT,
3018                finderArgs, this);
3019
3020        if (list == null) {
3021            Session session = null;
3022
3023            try {
3024                session = openSession();
3025
3026                StringBundler query = null;
3027
3028                if (orderByComparator != null) {
3029                    query = new StringBundler(4 +
3030                            (orderByComparator.getOrderByFields().length * 3));
3031                }
3032                else {
3033                    query = new StringBundler(4);
3034                }
3035
3036                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3037
3038                query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
3039
3040                if (urlTitle == null) {
3041                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
3042                }
3043                else {
3044                    if (urlTitle.equals(StringPool.BLANK)) {
3045                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
3046                    }
3047                    else {
3048                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
3049                    }
3050                }
3051
3052                if (orderByComparator != null) {
3053                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3054                        orderByComparator);
3055                }
3056
3057                else {
3058                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3059                }
3060
3061                String sql = query.toString();
3062
3063                Query q = session.createQuery(sql);
3064
3065                QueryPos qPos = QueryPos.getInstance(q);
3066
3067                qPos.add(groupId);
3068
3069                if (urlTitle != null) {
3070                    qPos.add(urlTitle);
3071                }
3072
3073                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
3074                        start, end);
3075            }
3076            catch (Exception e) {
3077                throw processException(e);
3078            }
3079            finally {
3080                if (list == null) {
3081                    list = new ArrayList<JournalArticle>();
3082                }
3083
3084                cacheResult(list);
3085
3086                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_UT,
3087                    finderArgs, list);
3088
3089                closeSession(session);
3090            }
3091        }
3092
3093        return list;
3094    }
3095
3096    public JournalArticle findByG_UT_First(long groupId, String urlTitle,
3097        OrderByComparator orderByComparator)
3098        throws NoSuchArticleException, SystemException {
3099        List<JournalArticle> list = findByG_UT(groupId, urlTitle, 0, 1,
3100                orderByComparator);
3101
3102        if (list.isEmpty()) {
3103            StringBundler msg = new StringBundler(6);
3104
3105            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3106
3107            msg.append("groupId=");
3108            msg.append(groupId);
3109
3110            msg.append(", urlTitle=");
3111            msg.append(urlTitle);
3112
3113            msg.append(StringPool.CLOSE_CURLY_BRACE);
3114
3115            throw new NoSuchArticleException(msg.toString());
3116        }
3117        else {
3118            return list.get(0);
3119        }
3120    }
3121
3122    public JournalArticle findByG_UT_Last(long groupId, String urlTitle,
3123        OrderByComparator orderByComparator)
3124        throws NoSuchArticleException, SystemException {
3125        int count = countByG_UT(groupId, urlTitle);
3126
3127        List<JournalArticle> list = findByG_UT(groupId, urlTitle, count - 1,
3128                count, orderByComparator);
3129
3130        if (list.isEmpty()) {
3131            StringBundler msg = new StringBundler(6);
3132
3133            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3134
3135            msg.append("groupId=");
3136            msg.append(groupId);
3137
3138            msg.append(", urlTitle=");
3139            msg.append(urlTitle);
3140
3141            msg.append(StringPool.CLOSE_CURLY_BRACE);
3142
3143            throw new NoSuchArticleException(msg.toString());
3144        }
3145        else {
3146            return list.get(0);
3147        }
3148    }
3149
3150    public JournalArticle[] findByG_UT_PrevAndNext(long id, long groupId,
3151        String urlTitle, OrderByComparator orderByComparator)
3152        throws NoSuchArticleException, SystemException {
3153        JournalArticle journalArticle = findByPrimaryKey(id);
3154
3155        int count = countByG_UT(groupId, urlTitle);
3156
3157        Session session = null;
3158
3159        try {
3160            session = openSession();
3161
3162            StringBundler query = null;
3163
3164            if (orderByComparator != null) {
3165                query = new StringBundler(4 +
3166                        (orderByComparator.getOrderByFields().length * 3));
3167            }
3168            else {
3169                query = new StringBundler(4);
3170            }
3171
3172            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3173
3174            query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
3175
3176            if (urlTitle == null) {
3177                query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
3178            }
3179            else {
3180                if (urlTitle.equals(StringPool.BLANK)) {
3181                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
3182                }
3183                else {
3184                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
3185                }
3186            }
3187
3188            if (orderByComparator != null) {
3189                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3190                    orderByComparator);
3191            }
3192
3193            else {
3194                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3195            }
3196
3197            String sql = query.toString();
3198
3199            Query q = session.createQuery(sql);
3200
3201            QueryPos qPos = QueryPos.getInstance(q);
3202
3203            qPos.add(groupId);
3204
3205            if (urlTitle != null) {
3206                qPos.add(urlTitle);
3207            }
3208
3209            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
3210                    orderByComparator, journalArticle);
3211
3212            JournalArticle[] array = new JournalArticleImpl[3];
3213
3214            array[0] = (JournalArticle)objArray[0];
3215            array[1] = (JournalArticle)objArray[1];
3216            array[2] = (JournalArticle)objArray[2];
3217
3218            return array;
3219        }
3220        catch (Exception e) {
3221            throw processException(e);
3222        }
3223        finally {
3224            closeSession(session);
3225        }
3226    }
3227
3228    public List<JournalArticle> findByC_S(long companyId, int status)
3229        throws SystemException {
3230        Object[] finderArgs = new Object[] {
3231                new Long(companyId), new Integer(status)
3232            };
3233
3234        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_S,
3235                finderArgs, this);
3236
3237        if (list == null) {
3238            Session session = null;
3239
3240            try {
3241                session = openSession();
3242
3243                StringBundler query = new StringBundler(4);
3244
3245                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3246
3247                query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
3248
3249                query.append(_FINDER_COLUMN_C_S_STATUS_2);
3250
3251                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3252
3253                String sql = query.toString();
3254
3255                Query q = session.createQuery(sql);
3256
3257                QueryPos qPos = QueryPos.getInstance(q);
3258
3259                qPos.add(companyId);
3260
3261                qPos.add(status);
3262
3263                list = q.list();
3264            }
3265            catch (Exception e) {
3266                throw processException(e);
3267            }
3268            finally {
3269                if (list == null) {
3270                    list = new ArrayList<JournalArticle>();
3271                }
3272
3273                cacheResult(list);
3274
3275                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_S, finderArgs,
3276                    list);
3277
3278                closeSession(session);
3279            }
3280        }
3281
3282        return list;
3283    }
3284
3285    public List<JournalArticle> findByC_S(long companyId, int status,
3286        int start, int end) throws SystemException {
3287        return findByC_S(companyId, status, start, end, null);
3288    }
3289
3290    public List<JournalArticle> findByC_S(long companyId, int status,
3291        int start, int end, OrderByComparator orderByComparator)
3292        throws SystemException {
3293        Object[] finderArgs = new Object[] {
3294                new Long(companyId), new Integer(status),
3295                
3296                String.valueOf(start), String.valueOf(end),
3297                String.valueOf(orderByComparator)
3298            };
3299
3300        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_S,
3301                finderArgs, this);
3302
3303        if (list == null) {
3304            Session session = null;
3305
3306            try {
3307                session = openSession();
3308
3309                StringBundler query = null;
3310
3311                if (orderByComparator != null) {
3312                    query = new StringBundler(4 +
3313                            (orderByComparator.getOrderByFields().length * 3));
3314                }
3315                else {
3316                    query = new StringBundler(4);
3317                }
3318
3319                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3320
3321                query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
3322
3323                query.append(_FINDER_COLUMN_C_S_STATUS_2);
3324
3325                if (orderByComparator != null) {
3326                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3327                        orderByComparator);
3328                }
3329
3330                else {
3331                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3332                }
3333
3334                String sql = query.toString();
3335
3336                Query q = session.createQuery(sql);
3337
3338                QueryPos qPos = QueryPos.getInstance(q);
3339
3340                qPos.add(companyId);
3341
3342                qPos.add(status);
3343
3344                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
3345                        start, end);
3346            }
3347            catch (Exception e) {
3348                throw processException(e);
3349            }
3350            finally {
3351                if (list == null) {
3352                    list = new ArrayList<JournalArticle>();
3353                }
3354
3355                cacheResult(list);
3356
3357                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_S,
3358                    finderArgs, list);
3359
3360                closeSession(session);
3361            }
3362        }
3363
3364        return list;
3365    }
3366
3367    public JournalArticle findByC_S_First(long companyId, int status,
3368        OrderByComparator orderByComparator)
3369        throws NoSuchArticleException, SystemException {
3370        List<JournalArticle> list = findByC_S(companyId, status, 0, 1,
3371                orderByComparator);
3372
3373        if (list.isEmpty()) {
3374            StringBundler msg = new StringBundler(6);
3375
3376            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3377
3378            msg.append("companyId=");
3379            msg.append(companyId);
3380
3381            msg.append(", status=");
3382            msg.append(status);
3383
3384            msg.append(StringPool.CLOSE_CURLY_BRACE);
3385
3386            throw new NoSuchArticleException(msg.toString());
3387        }
3388        else {
3389            return list.get(0);
3390        }
3391    }
3392
3393    public JournalArticle findByC_S_Last(long companyId, int status,
3394        OrderByComparator orderByComparator)
3395        throws NoSuchArticleException, SystemException {
3396        int count = countByC_S(companyId, status);
3397
3398        List<JournalArticle> list = findByC_S(companyId, status, count - 1,
3399                count, orderByComparator);
3400
3401        if (list.isEmpty()) {
3402            StringBundler msg = new StringBundler(6);
3403
3404            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3405
3406            msg.append("companyId=");
3407            msg.append(companyId);
3408
3409            msg.append(", status=");
3410            msg.append(status);
3411
3412            msg.append(StringPool.CLOSE_CURLY_BRACE);
3413
3414            throw new NoSuchArticleException(msg.toString());
3415        }
3416        else {
3417            return list.get(0);
3418        }
3419    }
3420
3421    public JournalArticle[] findByC_S_PrevAndNext(long id, long companyId,
3422        int status, OrderByComparator orderByComparator)
3423        throws NoSuchArticleException, SystemException {
3424        JournalArticle journalArticle = findByPrimaryKey(id);
3425
3426        int count = countByC_S(companyId, status);
3427
3428        Session session = null;
3429
3430        try {
3431            session = openSession();
3432
3433            StringBundler query = null;
3434
3435            if (orderByComparator != null) {
3436                query = new StringBundler(4 +
3437                        (orderByComparator.getOrderByFields().length * 3));
3438            }
3439            else {
3440                query = new StringBundler(4);
3441            }
3442
3443            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3444
3445            query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
3446
3447            query.append(_FINDER_COLUMN_C_S_STATUS_2);
3448
3449            if (orderByComparator != null) {
3450                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3451                    orderByComparator);
3452            }
3453
3454            else {
3455                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3456            }
3457
3458            String sql = query.toString();
3459
3460            Query q = session.createQuery(sql);
3461
3462            QueryPos qPos = QueryPos.getInstance(q);
3463
3464            qPos.add(companyId);
3465
3466            qPos.add(status);
3467
3468            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
3469                    orderByComparator, journalArticle);
3470
3471            JournalArticle[] array = new JournalArticleImpl[3];
3472
3473            array[0] = (JournalArticle)objArray[0];
3474            array[1] = (JournalArticle)objArray[1];
3475            array[2] = (JournalArticle)objArray[2];
3476
3477            return array;
3478        }
3479        catch (Exception e) {
3480            throw processException(e);
3481        }
3482        finally {
3483            closeSession(session);
3484        }
3485    }
3486
3487    public JournalArticle findByG_A_V(long groupId, String articleId,
3488        double version) throws NoSuchArticleException, SystemException {
3489        JournalArticle journalArticle = fetchByG_A_V(groupId, articleId, version);
3490
3491        if (journalArticle == null) {
3492            StringBundler msg = new StringBundler(8);
3493
3494            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3495
3496            msg.append("groupId=");
3497            msg.append(groupId);
3498
3499            msg.append(", articleId=");
3500            msg.append(articleId);
3501
3502            msg.append(", version=");
3503            msg.append(version);
3504
3505            msg.append(StringPool.CLOSE_CURLY_BRACE);
3506
3507            if (_log.isWarnEnabled()) {
3508                _log.warn(msg.toString());
3509            }
3510
3511            throw new NoSuchArticleException(msg.toString());
3512        }
3513
3514        return journalArticle;
3515    }
3516
3517    public JournalArticle fetchByG_A_V(long groupId, String articleId,
3518        double version) throws SystemException {
3519        return fetchByG_A_V(groupId, articleId, version, true);
3520    }
3521
3522    public JournalArticle fetchByG_A_V(long groupId, String articleId,
3523        double version, boolean retrieveFromCache) throws SystemException {
3524        Object[] finderArgs = new Object[] {
3525                new Long(groupId),
3526                
3527                articleId, new Double(version)
3528            };
3529
3530        Object result = null;
3531
3532        if (retrieveFromCache) {
3533            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A_V,
3534                    finderArgs, this);
3535        }
3536
3537        if (result == null) {
3538            Session session = null;
3539
3540            try {
3541                session = openSession();
3542
3543                StringBundler query = new StringBundler(5);
3544
3545                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3546
3547                query.append(_FINDER_COLUMN_G_A_V_GROUPID_2);
3548
3549                if (articleId == null) {
3550                    query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_1);
3551                }
3552                else {
3553                    if (articleId.equals(StringPool.BLANK)) {
3554                        query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_3);
3555                    }
3556                    else {
3557                        query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_2);
3558                    }
3559                }
3560
3561                query.append(_FINDER_COLUMN_G_A_V_VERSION_2);
3562
3563                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3564
3565                String sql = query.toString();
3566
3567                Query q = session.createQuery(sql);
3568
3569                QueryPos qPos = QueryPos.getInstance(q);
3570
3571                qPos.add(groupId);
3572
3573                if (articleId != null) {
3574                    qPos.add(articleId);
3575                }
3576
3577                qPos.add(version);
3578
3579                List<JournalArticle> list = q.list();
3580
3581                result = list;
3582
3583                JournalArticle journalArticle = null;
3584
3585                if (list.isEmpty()) {
3586                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
3587                        finderArgs, list);
3588                }
3589                else {
3590                    journalArticle = list.get(0);
3591
3592                    cacheResult(journalArticle);
3593
3594                    if ((journalArticle.getGroupId() != groupId) ||
3595                            (journalArticle.getArticleId() == null) ||
3596                            !journalArticle.getArticleId().equals(articleId) ||
3597                            (journalArticle.getVersion() != version)) {
3598                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
3599                            finderArgs, journalArticle);
3600                    }
3601                }
3602
3603                return journalArticle;
3604            }
3605            catch (Exception e) {
3606                throw processException(e);
3607            }
3608            finally {
3609                if (result == null) {
3610                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
3611                        finderArgs, new ArrayList<JournalArticle>());
3612                }
3613
3614                closeSession(session);
3615            }
3616        }
3617        else {
3618            if (result instanceof List<?>) {
3619                return null;
3620            }
3621            else {
3622                return (JournalArticle)result;
3623            }
3624        }
3625    }
3626
3627    public List<JournalArticle> findByG_A_S(long groupId, String articleId,
3628        int status) throws SystemException {
3629        Object[] finderArgs = new Object[] {
3630                new Long(groupId),
3631                
3632                articleId, new Integer(status)
3633            };
3634
3635        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A_S,
3636                finderArgs, this);
3637
3638        if (list == null) {
3639            Session session = null;
3640
3641            try {
3642                session = openSession();
3643
3644                StringBundler query = new StringBundler(5);
3645
3646                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3647
3648                query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
3649
3650                if (articleId == null) {
3651                    query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_1);
3652                }
3653                else {
3654                    if (articleId.equals(StringPool.BLANK)) {
3655                        query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_3);
3656                    }
3657                    else {
3658                        query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_2);
3659                    }
3660                }
3661
3662                query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
3663
3664                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3665
3666                String sql = query.toString();
3667
3668                Query q = session.createQuery(sql);
3669
3670                QueryPos qPos = QueryPos.getInstance(q);
3671
3672                qPos.add(groupId);
3673
3674                if (articleId != null) {
3675                    qPos.add(articleId);
3676                }
3677
3678                qPos.add(status);
3679
3680                list = q.list();
3681            }
3682            catch (Exception e) {
3683                throw processException(e);
3684            }
3685            finally {
3686                if (list == null) {
3687                    list = new ArrayList<JournalArticle>();
3688                }
3689
3690                cacheResult(list);
3691
3692                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A_S,
3693                    finderArgs, list);
3694
3695                closeSession(session);
3696            }
3697        }
3698
3699        return list;
3700    }
3701
3702    public List<JournalArticle> findByG_A_S(long groupId, String articleId,
3703        int status, int start, int end) throws SystemException {
3704        return findByG_A_S(groupId, articleId, status, start, end, null);
3705    }
3706
3707    public List<JournalArticle> findByG_A_S(long groupId, String articleId,
3708        int status, int start, int end, OrderByComparator orderByComparator)
3709        throws SystemException {
3710        Object[] finderArgs = new Object[] {
3711                new Long(groupId),
3712                
3713                articleId, new Integer(status),
3714                
3715                String.valueOf(start), String.valueOf(end),
3716                String.valueOf(orderByComparator)
3717            };
3718
3719        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_A_S,
3720                finderArgs, this);
3721
3722        if (list == null) {
3723            Session session = null;
3724
3725            try {
3726                session = openSession();
3727
3728                StringBundler query = null;
3729
3730                if (orderByComparator != null) {
3731                    query = new StringBundler(5 +
3732                            (orderByComparator.getOrderByFields().length * 3));
3733                }
3734                else {
3735                    query = new StringBundler(5);
3736                }
3737
3738                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3739
3740                query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
3741
3742                if (articleId == null) {
3743                    query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_1);
3744                }
3745                else {
3746                    if (articleId.equals(StringPool.BLANK)) {
3747                        query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_3);
3748                    }
3749                    else {
3750                        query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_2);
3751                    }
3752                }
3753
3754                query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
3755
3756                if (orderByComparator != null) {
3757                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3758                        orderByComparator);
3759                }
3760
3761                else {
3762                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3763                }
3764
3765                String sql = query.toString();
3766
3767                Query q = session.createQuery(sql);
3768
3769                QueryPos qPos = QueryPos.getInstance(q);
3770
3771                qPos.add(groupId);
3772
3773                if (articleId != null) {
3774                    qPos.add(articleId);
3775                }
3776
3777                qPos.add(status);
3778
3779                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
3780                        start, end);
3781            }
3782            catch (Exception e) {
3783                throw processException(e);
3784            }
3785            finally {
3786                if (list == null) {
3787                    list = new ArrayList<JournalArticle>();
3788                }
3789
3790                cacheResult(list);
3791
3792                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_A_S,
3793                    finderArgs, list);
3794
3795                closeSession(session);
3796            }
3797        }
3798
3799        return list;
3800    }
3801
3802    public JournalArticle findByG_A_S_First(long groupId, String articleId,
3803        int status, OrderByComparator orderByComparator)
3804        throws NoSuchArticleException, SystemException {
3805        List<JournalArticle> list = findByG_A_S(groupId, articleId, status, 0,
3806                1, orderByComparator);
3807
3808        if (list.isEmpty()) {
3809            StringBundler msg = new StringBundler(8);
3810
3811            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3812
3813            msg.append("groupId=");
3814            msg.append(groupId);
3815
3816            msg.append(", articleId=");
3817            msg.append(articleId);
3818
3819            msg.append(", status=");
3820            msg.append(status);
3821
3822            msg.append(StringPool.CLOSE_CURLY_BRACE);
3823
3824            throw new NoSuchArticleException(msg.toString());
3825        }
3826        else {
3827            return list.get(0);
3828        }
3829    }
3830
3831    public JournalArticle findByG_A_S_Last(long groupId, String articleId,
3832        int status, OrderByComparator orderByComparator)
3833        throws NoSuchArticleException, SystemException {
3834        int count = countByG_A_S(groupId, articleId, status);
3835
3836        List<JournalArticle> list = findByG_A_S(groupId, articleId, status,
3837                count - 1, count, orderByComparator);
3838
3839        if (list.isEmpty()) {
3840            StringBundler msg = new StringBundler(8);
3841
3842            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3843
3844            msg.append("groupId=");
3845            msg.append(groupId);
3846
3847            msg.append(", articleId=");
3848            msg.append(articleId);
3849
3850            msg.append(", status=");
3851            msg.append(status);
3852
3853            msg.append(StringPool.CLOSE_CURLY_BRACE);
3854
3855            throw new NoSuchArticleException(msg.toString());
3856        }
3857        else {
3858            return list.get(0);
3859        }
3860    }
3861
3862    public JournalArticle[] findByG_A_S_PrevAndNext(long id, long groupId,
3863        String articleId, int status, OrderByComparator orderByComparator)
3864        throws NoSuchArticleException, SystemException {
3865        JournalArticle journalArticle = findByPrimaryKey(id);
3866
3867        int count = countByG_A_S(groupId, articleId, status);
3868
3869        Session session = null;
3870
3871        try {
3872            session = openSession();
3873
3874            StringBundler query = null;
3875
3876            if (orderByComparator != null) {
3877                query = new StringBundler(5 +
3878                        (orderByComparator.getOrderByFields().length * 3));
3879            }
3880            else {
3881                query = new StringBundler(5);
3882            }
3883
3884            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3885
3886            query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
3887
3888            if (articleId == null) {
3889                query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_1);
3890            }
3891            else {
3892                if (articleId.equals(StringPool.BLANK)) {
3893                    query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_3);
3894                }
3895                else {
3896                    query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_2);
3897                }
3898            }
3899
3900            query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
3901
3902            if (orderByComparator != null) {
3903                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3904                    orderByComparator);
3905            }
3906
3907            else {
3908                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3909            }
3910
3911            String sql = query.toString();
3912
3913            Query q = session.createQuery(sql);
3914
3915            QueryPos qPos = QueryPos.getInstance(q);
3916
3917            qPos.add(groupId);
3918
3919            if (articleId != null) {
3920                qPos.add(articleId);
3921            }
3922
3923            qPos.add(status);
3924
3925            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
3926                    orderByComparator, journalArticle);
3927
3928            JournalArticle[] array = new JournalArticleImpl[3];
3929
3930            array[0] = (JournalArticle)objArray[0];
3931            array[1] = (JournalArticle)objArray[1];
3932            array[2] = (JournalArticle)objArray[2];
3933
3934            return array;
3935        }
3936        catch (Exception e) {
3937            throw processException(e);
3938        }
3939        finally {
3940            closeSession(session);
3941        }
3942    }
3943
3944    public List<JournalArticle> findByG_UT_S(long groupId, String urlTitle,
3945        int status) throws SystemException {
3946        Object[] finderArgs = new Object[] {
3947                new Long(groupId),
3948                
3949                urlTitle, new Integer(status)
3950            };
3951
3952        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_UT_S,
3953                finderArgs, this);
3954
3955        if (list == null) {
3956            Session session = null;
3957
3958            try {
3959                session = openSession();
3960
3961                StringBundler query = new StringBundler(5);
3962
3963                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3964
3965                query.append(_FINDER_COLUMN_G_UT_S_GROUPID_2);
3966
3967                if (urlTitle == null) {
3968                    query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_1);
3969                }
3970                else {
3971                    if (urlTitle.equals(StringPool.BLANK)) {
3972                        query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_3);
3973                    }
3974                    else {
3975                        query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_2);
3976                    }
3977                }
3978
3979                query.append(_FINDER_COLUMN_G_UT_S_STATUS_2);
3980
3981                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3982
3983                String sql = query.toString();
3984
3985                Query q = session.createQuery(sql);
3986
3987                QueryPos qPos = QueryPos.getInstance(q);
3988
3989                qPos.add(groupId);
3990
3991                if (urlTitle != null) {
3992                    qPos.add(urlTitle);
3993                }
3994
3995                qPos.add(status);
3996
3997                list = q.list();
3998            }
3999            catch (Exception e) {
4000                throw processException(e);
4001            }
4002            finally {
4003                if (list == null) {
4004                    list = new ArrayList<JournalArticle>();
4005                }
4006
4007                cacheResult(list);
4008
4009                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_UT_S,
4010                    finderArgs, list);
4011
4012                closeSession(session);
4013            }
4014        }
4015
4016        return list;
4017    }
4018
4019    public List<JournalArticle> findByG_UT_S(long groupId, String urlTitle,
4020        int status, int start, int end) throws SystemException {
4021        return findByG_UT_S(groupId, urlTitle, status, start, end, null);
4022    }
4023
4024    public List<JournalArticle> findByG_UT_S(long groupId, String urlTitle,
4025        int status, int start, int end, OrderByComparator orderByComparator)
4026        throws SystemException {
4027        Object[] finderArgs = new Object[] {
4028                new Long(groupId),
4029                
4030                urlTitle, new Integer(status),
4031                
4032                String.valueOf(start), String.valueOf(end),
4033                String.valueOf(orderByComparator)
4034            };
4035
4036        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_UT_S,
4037                finderArgs, this);
4038
4039        if (list == null) {
4040            Session session = null;
4041
4042            try {
4043                session = openSession();
4044
4045                StringBundler query = null;
4046
4047                if (orderByComparator != null) {
4048                    query = new StringBundler(5 +
4049                            (orderByComparator.getOrderByFields().length * 3));
4050                }
4051                else {
4052                    query = new StringBundler(5);
4053                }
4054
4055                query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
4056
4057                query.append(_FINDER_COLUMN_G_UT_S_GROUPID_2);
4058
4059                if (urlTitle == null) {
4060                    query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_1);
4061                }
4062                else {
4063                    if (urlTitle.equals(StringPool.BLANK)) {
4064                        query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_3);
4065                    }
4066                    else {
4067                        query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_2);
4068                    }
4069                }
4070
4071                query.append(_FINDER_COLUMN_G_UT_S_STATUS_2);
4072
4073                if (orderByComparator != null) {
4074                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4075                        orderByComparator);
4076                }
4077
4078                else {
4079                    query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
4080                }
4081
4082                String sql = query.toString();
4083
4084                Query q = session.createQuery(sql);
4085
4086                QueryPos qPos = QueryPos.getInstance(q);
4087
4088                qPos.add(groupId);
4089
4090                if (urlTitle != null) {
4091                    qPos.add(urlTitle);
4092                }
4093
4094                qPos.add(status);
4095
4096                list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
4097                        start, end);
4098            }
4099            catch (Exception e) {
4100                throw processException(e);
4101            }
4102            finally {
4103                if (list == null) {
4104                    list = new ArrayList<JournalArticle>();
4105                }
4106
4107                cacheResult(list);
4108
4109                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_UT_S,
4110                    finderArgs, list);
4111
4112                closeSession(session);
4113            }
4114        }
4115
4116        return list;
4117    }
4118
4119    public JournalArticle findByG_UT_S_First(long groupId, String urlTitle,
4120        int status, OrderByComparator orderByComparator)
4121        throws NoSuchArticleException, SystemException {
4122        List<JournalArticle> list = findByG_UT_S(groupId, urlTitle, status, 0,
4123                1, orderByComparator);
4124
4125        if (list.isEmpty()) {
4126            StringBundler msg = new StringBundler(8);
4127
4128            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4129
4130            msg.append("groupId=");
4131            msg.append(groupId);
4132
4133            msg.append(", urlTitle=");
4134            msg.append(urlTitle);
4135
4136            msg.append(", status=");
4137            msg.append(status);
4138
4139            msg.append(StringPool.CLOSE_CURLY_BRACE);
4140
4141            throw new NoSuchArticleException(msg.toString());
4142        }
4143        else {
4144            return list.get(0);
4145        }
4146    }
4147
4148    public JournalArticle findByG_UT_S_Last(long groupId, String urlTitle,
4149        int status, OrderByComparator orderByComparator)
4150        throws NoSuchArticleException, SystemException {
4151        int count = countByG_UT_S(groupId, urlTitle, status);
4152
4153        List<JournalArticle> list = findByG_UT_S(groupId, urlTitle, status,
4154                count - 1, count, orderByComparator);
4155
4156        if (list.isEmpty()) {
4157            StringBundler msg = new StringBundler(8);
4158
4159            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4160
4161            msg.append("groupId=");
4162            msg.append(groupId);
4163
4164            msg.append(", urlTitle=");
4165            msg.append(urlTitle);
4166
4167            msg.append(", status=");
4168            msg.append(status);
4169
4170            msg.append(StringPool.CLOSE_CURLY_BRACE);
4171
4172            throw new NoSuchArticleException(msg.toString());
4173        }
4174        else {
4175            return list.get(0);
4176        }
4177    }
4178
4179    public JournalArticle[] findByG_UT_S_PrevAndNext(long id, long groupId,
4180        String urlTitle, int status, OrderByComparator orderByComparator)
4181        throws NoSuchArticleException, SystemException {
4182        JournalArticle journalArticle = findByPrimaryKey(id);
4183
4184        int count = countByG_UT_S(groupId, urlTitle, status);
4185
4186        Session session = null;
4187
4188        try {
4189            session = openSession();
4190
4191            StringBundler query = null;
4192
4193            if (orderByComparator != null) {
4194                query = new StringBundler(5 +
4195                        (orderByComparator.getOrderByFields().length * 3));
4196            }
4197            else {
4198                query = new StringBundler(5);
4199            }
4200
4201            query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
4202
4203            query.append(_FINDER_COLUMN_G_UT_S_GROUPID_2);
4204
4205            if (urlTitle == null) {
4206                query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_1);
4207            }
4208            else {
4209                if (urlTitle.equals(StringPool.BLANK)) {
4210                    query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_3);
4211                }
4212                else {
4213                    query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_2);
4214                }
4215            }
4216
4217            query.append(_FINDER_COLUMN_G_UT_S_STATUS_2);
4218
4219            if (orderByComparator != null) {
4220                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4221                    orderByComparator);
4222            }
4223
4224            else {
4225                query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
4226            }
4227
4228            String sql = query.toString();
4229
4230            Query q = session.createQuery(sql);
4231
4232            QueryPos qPos = QueryPos.getInstance(q);
4233
4234            qPos.add(groupId);
4235
4236            if (urlTitle != null) {
4237                qPos.add(urlTitle);
4238            }
4239
4240            qPos.add(status);
4241
4242            Object[] objArray = QueryUtil.getPrevAndNext(q, count,
4243                    orderByComparator, journalArticle);
4244
4245            JournalArticle[] array = new JournalArticleImpl[3];
4246
4247            array[0] = (JournalArticle)objArray[0];
4248            array[1] = (JournalArticle)objArray[1];
4249            array[2] = (JournalArticle)objArray[2];
4250
4251            return array;
4252        }
4253        catch (Exception e) {
4254            throw processException(e);
4255        }
4256        finally {
4257            closeSession(session);
4258        }
4259    }
4260
4261    public List<JournalArticle> findAll() throws SystemException {
4262        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
4263    }
4264
4265    public List<JournalArticle> findAll(int start, int end)
4266        throws SystemException {
4267        return findAll(start, end, null);
4268    }
4269
4270    public List<JournalArticle> findAll(int start, int end,
4271        OrderByComparator orderByComparator) throws SystemException {
4272        Object[] finderArgs = new Object[] {
4273                String.valueOf(start), String.valueOf(end),
4274                String.valueOf(orderByComparator)
4275            };
4276
4277        List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
4278                finderArgs, this);
4279
4280        if (list == null) {
4281            Session session = null;
4282
4283            try {
4284                session = openSession();
4285
4286                StringBundler query = null;
4287                String sql = null;
4288
4289                if (orderByComparator != null) {
4290                    query = new StringBundler(2 +
4291                            (orderByComparator.getOrderByFields().length * 3));
4292
4293                    query.append(_SQL_SELECT_JOURNALARTICLE);
4294
4295                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4296                        orderByComparator);
4297
4298                    sql = query.toString();
4299                }
4300
4301                else {
4302                    sql = _SQL_SELECT_JOURNALARTICLE.concat(JournalArticleModelImpl.ORDER_BY_JPQL);
4303                }
4304
4305                Query q = session.createQuery(sql);
4306
4307                if (orderByComparator == null) {
4308                    list = (List<JournalArticle>)QueryUtil.list(q,
4309                            getDialect(), start, end, false);
4310
4311                    Collections.sort(list);
4312                }
4313                else {
4314                    list = (List<JournalArticle>)QueryUtil.list(q,
4315                            getDialect(), start, end);
4316                }
4317            }
4318            catch (Exception e) {
4319                throw processException(e);
4320            }
4321            finally {
4322                if (list == null) {
4323                    list = new ArrayList<JournalArticle>();
4324                }
4325
4326                cacheResult(list);
4327
4328                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
4329
4330                closeSession(session);
4331            }
4332        }
4333
4334        return list;
4335    }
4336
4337    public void removeByUuid(String uuid) throws SystemException {
4338        for (JournalArticle journalArticle : findByUuid(uuid)) {
4339            remove(journalArticle);
4340        }
4341    }
4342
4343    public void removeByUUID_G(String uuid, long groupId)
4344        throws NoSuchArticleException, SystemException {
4345        JournalArticle journalArticle = findByUUID_G(uuid, groupId);
4346
4347        remove(journalArticle);
4348    }
4349
4350    public void removeByGroupId(long groupId) throws SystemException {
4351        for (JournalArticle journalArticle : findByGroupId(groupId)) {
4352            remove(journalArticle);
4353        }
4354    }
4355
4356    public void removeByCompanyId(long companyId) throws SystemException {
4357        for (JournalArticle journalArticle : findByCompanyId(companyId)) {
4358            remove(journalArticle);
4359        }
4360    }
4361
4362    public void removeBySmallImageId(long smallImageId)
4363        throws SystemException {
4364        for (JournalArticle journalArticle : findBySmallImageId(smallImageId)) {
4365            remove(journalArticle);
4366        }
4367    }
4368
4369    public void removeByR_S(long resourcePrimKey, int status)
4370        throws SystemException {
4371        for (JournalArticle journalArticle : findByR_S(resourcePrimKey, status)) {
4372            remove(journalArticle);
4373        }
4374    }
4375
4376    public void removeByG_A(long groupId, String articleId)
4377        throws SystemException {
4378        for (JournalArticle journalArticle : findByG_A(groupId, articleId)) {
4379            remove(journalArticle);
4380        }
4381    }
4382
4383    public void removeByG_S(long groupId, String structureId)
4384        throws SystemException {
4385        for (JournalArticle journalArticle : findByG_S(groupId, structureId)) {
4386            remove(journalArticle);
4387        }
4388    }
4389
4390    public void removeByG_T(long groupId, String templateId)
4391        throws SystemException {
4392        for (JournalArticle journalArticle : findByG_T(groupId, templateId)) {
4393            remove(journalArticle);
4394        }
4395    }
4396
4397    public void removeByG_UT(long groupId, String urlTitle)
4398        throws SystemException {
4399        for (JournalArticle journalArticle : findByG_UT(groupId, urlTitle)) {
4400            remove(journalArticle);
4401        }
4402    }
4403
4404    public void removeByC_S(long companyId, int status)
4405        throws SystemException {
4406        for (JournalArticle journalArticle : findByC_S(companyId, status)) {
4407            remove(journalArticle);
4408        }
4409    }
4410
4411    public void removeByG_A_V(long groupId, String articleId, double version)
4412        throws NoSuchArticleException, SystemException {
4413        JournalArticle journalArticle = findByG_A_V(groupId, articleId, version);
4414
4415        remove(journalArticle);
4416    }
4417
4418    public void removeByG_A_S(long groupId, String articleId, int status)
4419        throws SystemException {
4420        for (JournalArticle journalArticle : findByG_A_S(groupId, articleId,
4421                status)) {
4422            remove(journalArticle);
4423        }
4424    }
4425
4426    public void removeByG_UT_S(long groupId, String urlTitle, int status)
4427        throws SystemException {
4428        for (JournalArticle journalArticle : findByG_UT_S(groupId, urlTitle,
4429                status)) {
4430            remove(journalArticle);
4431        }
4432    }
4433
4434    public void removeAll() throws SystemException {
4435        for (JournalArticle journalArticle : findAll()) {
4436            remove(journalArticle);
4437        }
4438    }
4439
4440    public int countByUuid(String uuid) throws SystemException {
4441        Object[] finderArgs = new Object[] { uuid };
4442
4443        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
4444                finderArgs, this);
4445
4446        if (count == null) {
4447            Session session = null;
4448
4449            try {
4450                session = openSession();
4451
4452                StringBundler query = new StringBundler(2);
4453
4454                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4455
4456                if (uuid == null) {
4457                    query.append(_FINDER_COLUMN_UUID_UUID_1);
4458                }
4459                else {
4460                    if (uuid.equals(StringPool.BLANK)) {
4461                        query.append(_FINDER_COLUMN_UUID_UUID_3);
4462                    }
4463                    else {
4464                        query.append(_FINDER_COLUMN_UUID_UUID_2);
4465                    }
4466                }
4467
4468                String sql = query.toString();
4469
4470                Query q = session.createQuery(sql);
4471
4472                QueryPos qPos = QueryPos.getInstance(q);
4473
4474                if (uuid != null) {
4475                    qPos.add(uuid);
4476                }
4477
4478                count = (Long)q.uniqueResult();
4479            }
4480            catch (Exception e) {
4481                throw processException(e);
4482            }
4483            finally {
4484                if (count == null) {
4485                    count = Long.valueOf(0);
4486                }
4487
4488                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
4489                    finderArgs, count);
4490
4491                closeSession(session);
4492            }
4493        }
4494
4495        return count.intValue();
4496    }
4497
4498    public int countByUUID_G(String uuid, long groupId)
4499        throws SystemException {
4500        Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
4501
4502        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
4503                finderArgs, this);
4504
4505        if (count == null) {
4506            Session session = null;
4507
4508            try {
4509                session = openSession();
4510
4511                StringBundler query = new StringBundler(3);
4512
4513                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4514
4515                if (uuid == null) {
4516                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
4517                }
4518                else {
4519                    if (uuid.equals(StringPool.BLANK)) {
4520                        query.append(_FINDER_COLUMN_UUID_G_UUID_3);
4521                    }
4522                    else {
4523                        query.append(_FINDER_COLUMN_UUID_G_UUID_2);
4524                    }
4525                }
4526
4527                query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
4528
4529                String sql = query.toString();
4530
4531                Query q = session.createQuery(sql);
4532
4533                QueryPos qPos = QueryPos.getInstance(q);
4534
4535                if (uuid != null) {
4536                    qPos.add(uuid);
4537                }
4538
4539                qPos.add(groupId);
4540
4541                count = (Long)q.uniqueResult();
4542            }
4543            catch (Exception e) {
4544                throw processException(e);
4545            }
4546            finally {
4547                if (count == null) {
4548                    count = Long.valueOf(0);
4549                }
4550
4551                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
4552                    finderArgs, count);
4553
4554                closeSession(session);
4555            }
4556        }
4557
4558        return count.intValue();
4559    }
4560
4561    public int countByGroupId(long groupId) throws SystemException {
4562        Object[] finderArgs = new Object[] { new Long(groupId) };
4563
4564        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
4565                finderArgs, this);
4566
4567        if (count == null) {
4568            Session session = null;
4569
4570            try {
4571                session = openSession();
4572
4573                StringBundler query = new StringBundler(2);
4574
4575                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4576
4577                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
4578
4579                String sql = query.toString();
4580
4581                Query q = session.createQuery(sql);
4582
4583                QueryPos qPos = QueryPos.getInstance(q);
4584
4585                qPos.add(groupId);
4586
4587                count = (Long)q.uniqueResult();
4588            }
4589            catch (Exception e) {
4590                throw processException(e);
4591            }
4592            finally {
4593                if (count == null) {
4594                    count = Long.valueOf(0);
4595                }
4596
4597                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
4598                    finderArgs, count);
4599
4600                closeSession(session);
4601            }
4602        }
4603
4604        return count.intValue();
4605    }
4606
4607    public int countByCompanyId(long companyId) throws SystemException {
4608        Object[] finderArgs = new Object[] { new Long(companyId) };
4609
4610        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
4611                finderArgs, this);
4612
4613        if (count == null) {
4614            Session session = null;
4615
4616            try {
4617                session = openSession();
4618
4619                StringBundler query = new StringBundler(2);
4620
4621                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4622
4623                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
4624
4625                String sql = query.toString();
4626
4627                Query q = session.createQuery(sql);
4628
4629                QueryPos qPos = QueryPos.getInstance(q);
4630
4631                qPos.add(companyId);
4632
4633                count = (Long)q.uniqueResult();
4634            }
4635            catch (Exception e) {
4636                throw processException(e);
4637            }
4638            finally {
4639                if (count == null) {
4640                    count = Long.valueOf(0);
4641                }
4642
4643                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
4644                    finderArgs, count);
4645
4646                closeSession(session);
4647            }
4648        }
4649
4650        return count.intValue();
4651    }
4652
4653    public int countBySmallImageId(long smallImageId) throws SystemException {
4654        Object[] finderArgs = new Object[] { new Long(smallImageId) };
4655
4656        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SMALLIMAGEID,
4657                finderArgs, this);
4658
4659        if (count == null) {
4660            Session session = null;
4661
4662            try {
4663                session = openSession();
4664
4665                StringBundler query = new StringBundler(2);
4666
4667                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4668
4669                query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
4670
4671                String sql = query.toString();
4672
4673                Query q = session.createQuery(sql);
4674
4675                QueryPos qPos = QueryPos.getInstance(q);
4676
4677                qPos.add(smallImageId);
4678
4679                count = (Long)q.uniqueResult();
4680            }
4681            catch (Exception e) {
4682                throw processException(e);
4683            }
4684            finally {
4685                if (count == null) {
4686                    count = Long.valueOf(0);
4687                }
4688
4689                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SMALLIMAGEID,
4690                    finderArgs, count);
4691
4692                closeSession(session);
4693            }
4694        }
4695
4696        return count.intValue();
4697    }
4698
4699    public int countByR_S(long resourcePrimKey, int status)
4700        throws SystemException {
4701        Object[] finderArgs = new Object[] {
4702                new Long(resourcePrimKey), new Integer(status)
4703            };
4704
4705        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_R_S,
4706                finderArgs, this);
4707
4708        if (count == null) {
4709            Session session = null;
4710
4711            try {
4712                session = openSession();
4713
4714                StringBundler query = new StringBundler(3);
4715
4716                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4717
4718                query.append(_FINDER_COLUMN_R_S_RESOURCEPRIMKEY_2);
4719
4720                query.append(_FINDER_COLUMN_R_S_STATUS_2);
4721
4722                String sql = query.toString();
4723
4724                Query q = session.createQuery(sql);
4725
4726                QueryPos qPos = QueryPos.getInstance(q);
4727
4728                qPos.add(resourcePrimKey);
4729
4730                qPos.add(status);
4731
4732                count = (Long)q.uniqueResult();
4733            }
4734            catch (Exception e) {
4735                throw processException(e);
4736            }
4737            finally {
4738                if (count == null) {
4739                    count = Long.valueOf(0);
4740                }
4741
4742                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_R_S, finderArgs,
4743                    count);
4744
4745                closeSession(session);
4746            }
4747        }
4748
4749        return count.intValue();
4750    }
4751
4752    public int countByG_A(long groupId, String articleId)
4753        throws SystemException {
4754        Object[] finderArgs = new Object[] { new Long(groupId), articleId };
4755
4756        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
4757                finderArgs, this);
4758
4759        if (count == null) {
4760            Session session = null;
4761
4762            try {
4763                session = openSession();
4764
4765                StringBundler query = new StringBundler(3);
4766
4767                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4768
4769                query.append(_FINDER_COLUMN_G_A_GROUPID_2);
4770
4771                if (articleId == null) {
4772                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
4773                }
4774                else {
4775                    if (articleId.equals(StringPool.BLANK)) {
4776                        query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
4777                    }
4778                    else {
4779                        query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
4780                    }
4781                }
4782
4783                String sql = query.toString();
4784
4785                Query q = session.createQuery(sql);
4786
4787                QueryPos qPos = QueryPos.getInstance(q);
4788
4789                qPos.add(groupId);
4790
4791                if (articleId != null) {
4792                    qPos.add(articleId);
4793                }
4794
4795                count = (Long)q.uniqueResult();
4796            }
4797            catch (Exception e) {
4798                throw processException(e);
4799            }
4800            finally {
4801                if (count == null) {
4802                    count = Long.valueOf(0);
4803                }
4804
4805                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
4806                    count);
4807
4808                closeSession(session);
4809            }
4810        }
4811
4812        return count.intValue();
4813    }
4814
4815    public int countByG_S(long groupId, String structureId)
4816        throws SystemException {
4817        Object[] finderArgs = new Object[] { new Long(groupId), structureId };
4818
4819        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_S,
4820                finderArgs, this);
4821
4822        if (count == null) {
4823            Session session = null;
4824
4825            try {
4826                session = openSession();
4827
4828                StringBundler query = new StringBundler(3);
4829
4830                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4831
4832                query.append(_FINDER_COLUMN_G_S_GROUPID_2);
4833
4834                if (structureId == null) {
4835                    query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
4836                }
4837                else {
4838                    if (structureId.equals(StringPool.BLANK)) {
4839                        query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
4840                    }
4841                    else {
4842                        query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
4843                    }
4844                }
4845
4846                String sql = query.toString();
4847
4848                Query q = session.createQuery(sql);
4849
4850                QueryPos qPos = QueryPos.getInstance(q);
4851
4852                qPos.add(groupId);
4853
4854                if (structureId != null) {
4855                    qPos.add(structureId);
4856                }
4857
4858                count = (Long)q.uniqueResult();
4859            }
4860            catch (Exception e) {
4861                throw processException(e);
4862            }
4863            finally {
4864                if (count == null) {
4865                    count = Long.valueOf(0);
4866                }
4867
4868                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_S, finderArgs,
4869                    count);
4870
4871                closeSession(session);
4872            }
4873        }
4874
4875        return count.intValue();
4876    }
4877
4878    public int countByG_T(long groupId, String templateId)
4879        throws SystemException {
4880        Object[] finderArgs = new Object[] { new Long(groupId), templateId };
4881
4882        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_T,
4883                finderArgs, this);
4884
4885        if (count == null) {
4886            Session session = null;
4887
4888            try {
4889                session = openSession();
4890
4891                StringBundler query = new StringBundler(3);
4892
4893                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4894
4895                query.append(_FINDER_COLUMN_G_T_GROUPID_2);
4896
4897                if (templateId == null) {
4898                    query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
4899                }
4900                else {
4901                    if (templateId.equals(StringPool.BLANK)) {
4902                        query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
4903                    }
4904                    else {
4905                        query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
4906                    }
4907                }
4908
4909                String sql = query.toString();
4910
4911                Query q = session.createQuery(sql);
4912
4913                QueryPos qPos = QueryPos.getInstance(q);
4914
4915                qPos.add(groupId);
4916
4917                if (templateId != null) {
4918                    qPos.add(templateId);
4919                }
4920
4921                count = (Long)q.uniqueResult();
4922            }
4923            catch (Exception e) {
4924                throw processException(e);
4925            }
4926            finally {
4927                if (count == null) {
4928                    count = Long.valueOf(0);
4929                }
4930
4931                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_T, finderArgs,
4932                    count);
4933
4934                closeSession(session);
4935            }
4936        }
4937
4938        return count.intValue();
4939    }
4940
4941    public int countByG_UT(long groupId, String urlTitle)
4942        throws SystemException {
4943        Object[] finderArgs = new Object[] { new Long(groupId), urlTitle };
4944
4945        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT,
4946                finderArgs, this);
4947
4948        if (count == null) {
4949            Session session = null;
4950
4951            try {
4952                session = openSession();
4953
4954                StringBundler query = new StringBundler(3);
4955
4956                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4957
4958                query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
4959
4960                if (urlTitle == null) {
4961                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
4962                }
4963                else {
4964                    if (urlTitle.equals(StringPool.BLANK)) {
4965                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
4966                    }
4967                    else {
4968                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
4969                    }
4970                }
4971
4972                String sql = query.toString();
4973
4974                Query q = session.createQuery(sql);
4975
4976                QueryPos qPos = QueryPos.getInstance(q);
4977
4978                qPos.add(groupId);
4979
4980                if (urlTitle != null) {
4981                    qPos.add(urlTitle);
4982                }
4983
4984                count = (Long)q.uniqueResult();
4985            }
4986            catch (Exception e) {
4987                throw processException(e);
4988            }
4989            finally {
4990                if (count == null) {
4991                    count = Long.valueOf(0);
4992                }
4993
4994                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT,
4995                    finderArgs, count);
4996
4997                closeSession(session);
4998            }
4999        }
5000
5001        return count.intValue();
5002    }
5003
5004    public int countByC_S(long companyId, int status) throws SystemException {
5005        Object[] finderArgs = new Object[] {
5006                new Long(companyId), new Integer(status)
5007            };
5008
5009        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_S,
5010                finderArgs, this);
5011
5012        if (count == null) {
5013            Session session = null;
5014
5015            try {
5016                session = openSession();
5017
5018                StringBundler query = new StringBundler(3);
5019
5020                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
5021
5022                query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
5023
5024                query.append(_FINDER_COLUMN_C_S_STATUS_2);
5025
5026                String sql = query.toString();
5027
5028                Query q = session.createQuery(sql);
5029
5030                QueryPos qPos = QueryPos.getInstance(q);
5031
5032                qPos.add(companyId);
5033
5034                qPos.add(status);
5035
5036                count = (Long)q.uniqueResult();
5037            }
5038            catch (Exception e) {
5039                throw processException(e);
5040            }
5041            finally {
5042                if (count == null) {
5043                    count = Long.valueOf(0);
5044                }
5045
5046                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_S, finderArgs,
5047                    count);
5048
5049                closeSession(session);
5050            }
5051        }
5052
5053        return count.intValue();
5054    }
5055
5056    public int countByG_A_V(long groupId, String articleId, double version)
5057        throws SystemException {
5058        Object[] finderArgs = new Object[] {
5059                new Long(groupId),
5060                
5061                articleId, new Double(version)
5062            };
5063
5064        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_V,
5065                finderArgs, this);
5066
5067        if (count == null) {
5068            Session session = null;
5069
5070            try {
5071                session = openSession();
5072
5073                StringBundler query = new StringBundler(4);
5074
5075                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
5076
5077                query.append(_FINDER_COLUMN_G_A_V_GROUPID_2);
5078
5079                if (articleId == null) {
5080                    query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_1);
5081                }
5082                else {
5083                    if (articleId.equals(StringPool.BLANK)) {
5084                        query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_3);
5085                    }
5086                    else {
5087                        query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_2);
5088                    }
5089                }
5090
5091                query.append(_FINDER_COLUMN_G_A_V_VERSION_2);
5092
5093                String sql = query.toString();
5094
5095                Query q = session.createQuery(sql);
5096
5097                QueryPos qPos = QueryPos.getInstance(q);
5098
5099                qPos.add(groupId);
5100
5101                if (articleId != null) {
5102                    qPos.add(articleId);
5103                }
5104
5105                qPos.add(version);
5106
5107                count = (Long)q.uniqueResult();
5108            }
5109            catch (Exception e) {
5110                throw processException(e);
5111            }
5112            finally {
5113                if (count == null) {
5114                    count = Long.valueOf(0);
5115                }
5116
5117                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_V,
5118                    finderArgs, count);
5119
5120                closeSession(session);
5121            }
5122        }
5123
5124        return count.intValue();
5125    }
5126
5127    public int countByG_A_S(long groupId, String articleId, int status)
5128        throws SystemException {
5129        Object[] finderArgs = new Object[] {
5130                new Long(groupId),
5131                
5132                articleId, new Integer(status)
5133            };
5134
5135        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_S,
5136                finderArgs, this);
5137
5138        if (count == null) {
5139            Session session = null;
5140
5141            try {
5142                session = openSession();
5143
5144                StringBundler query = new StringBundler(4);
5145
5146                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
5147
5148                query.append(_FINDER_COLUMN_G_A_S_GROUPID_2);
5149
5150                if (articleId == null) {
5151                    query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_1);
5152                }
5153                else {
5154                    if (articleId.equals(StringPool.BLANK)) {
5155                        query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_3);
5156                    }
5157                    else {
5158                        query.append(_FINDER_COLUMN_G_A_S_ARTICLEID_2);
5159                    }
5160                }
5161
5162                query.append(_FINDER_COLUMN_G_A_S_STATUS_2);
5163
5164                String sql = query.toString();
5165
5166                Query q = session.createQuery(sql);
5167
5168                QueryPos qPos = QueryPos.getInstance(q);
5169
5170                qPos.add(groupId);
5171
5172                if (articleId != null) {
5173                    qPos.add(articleId);
5174                }
5175
5176                qPos.add(status);
5177
5178                count = (Long)q.uniqueResult();
5179            }
5180            catch (Exception e) {
5181                throw processException(e);
5182            }
5183            finally {
5184                if (count == null) {
5185                    count = Long.valueOf(0);
5186                }
5187
5188                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_S,
5189                    finderArgs, count);
5190
5191                closeSession(session);
5192            }
5193        }
5194
5195        return count.intValue();
5196    }
5197
5198    public int countByG_UT_S(long groupId, String urlTitle, int status)
5199        throws SystemException {
5200        Object[] finderArgs = new Object[] {
5201                new Long(groupId),
5202                
5203                urlTitle, new Integer(status)
5204            };
5205
5206        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT_S,
5207                finderArgs, this);
5208
5209        if (count == null) {
5210            Session session = null;
5211
5212            try {
5213                session = openSession();
5214
5215                StringBundler query = new StringBundler(4);
5216
5217                query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
5218
5219                query.append(_FINDER_COLUMN_G_UT_S_GROUPID_2);
5220
5221                if (urlTitle == null) {
5222                    query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_1);
5223                }
5224                else {
5225                    if (urlTitle.equals(StringPool.BLANK)) {
5226                        query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_3);
5227                    }
5228                    else {
5229                        query.append(_FINDER_COLUMN_G_UT_S_URLTITLE_2);
5230                    }
5231                }
5232
5233                query.append(_FINDER_COLUMN_G_UT_S_STATUS_2);
5234
5235                String sql = query.toString();
5236
5237                Query q = session.createQuery(sql);
5238
5239                QueryPos qPos = QueryPos.getInstance(q);
5240
5241                qPos.add(groupId);
5242
5243                if (urlTitle != null) {
5244                    qPos.add(urlTitle);
5245                }
5246
5247                qPos.add(status);
5248
5249                count = (Long)q.uniqueResult();
5250            }
5251            catch (Exception e) {
5252                throw processException(e);
5253            }
5254            finally {
5255                if (count == null) {
5256                    count = Long.valueOf(0);
5257                }
5258
5259                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT_S,
5260                    finderArgs, count);
5261
5262                closeSession(session);
5263            }
5264        }
5265
5266        return count.intValue();
5267    }
5268
5269    public int countAll() throws SystemException {
5270        Object[] finderArgs = new Object[0];
5271
5272        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
5273                finderArgs, this);
5274
5275        if (count == null) {
5276            Session session = null;
5277
5278            try {
5279                session = openSession();
5280
5281                Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLE);
5282
5283                count = (Long)q.uniqueResult();
5284            }
5285            catch (Exception e) {
5286                throw processException(e);
5287            }
5288            finally {
5289                if (count == null) {
5290                    count = Long.valueOf(0);
5291                }
5292
5293                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
5294                    count);
5295
5296                closeSession(session);
5297            }
5298        }
5299
5300        return count.intValue();
5301    }
5302
5303    public void afterPropertiesSet() {
5304        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
5305                    com.liferay.portal.util.PropsUtil.get(
5306                        "value.object.listener.com.liferay.portlet.journal.model.JournalArticle")));
5307
5308        if (listenerClassNames.length > 0) {
5309            try {
5310                List<ModelListener<JournalArticle>> listenersList = new ArrayList<ModelListener<JournalArticle>>();
5311
5312                for (String listenerClassName : listenerClassNames) {
5313                    listenersList.add((ModelListener<JournalArticle>)Class.forName(
5314                            listenerClassName).newInstance());
5315                }
5316
5317                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
5318            }
5319            catch (Exception e) {
5320                _log.error(e);
5321            }
5322        }
5323    }
5324
5325    @BeanReference(type = JournalArticlePersistence.class)
5326    protected JournalArticlePersistence journalArticlePersistence;
5327    @BeanReference(type = JournalArticleImagePersistence.class)
5328    protected JournalArticleImagePersistence journalArticleImagePersistence;
5329    @BeanReference(type = JournalArticleResourcePersistence.class)
5330    protected JournalArticleResourcePersistence journalArticleResourcePersistence;
5331    @BeanReference(type = JournalContentSearchPersistence.class)
5332    protected JournalContentSearchPersistence journalContentSearchPersistence;
5333    @BeanReference(type = JournalFeedPersistence.class)
5334    protected JournalFeedPersistence journalFeedPersistence;
5335    @BeanReference(type = JournalStructurePersistence.class)
5336    protected JournalStructurePersistence journalStructurePersistence;
5337    @BeanReference(type = JournalTemplatePersistence.class)
5338    protected JournalTemplatePersistence journalTemplatePersistence;
5339    @BeanReference(type = CompanyPersistence.class)
5340    protected CompanyPersistence companyPersistence;
5341    @BeanReference(type = GroupPersistence.class)
5342    protected GroupPersistence groupPersistence;
5343    @BeanReference(type = ImagePersistence.class)
5344    protected ImagePersistence imagePersistence;
5345    @BeanReference(type = PortletPreferencesPersistence.class)
5346    protected PortletPreferencesPersistence portletPreferencesPersistence;
5347    @BeanReference(type = ResourcePersistence.class)
5348    protected ResourcePersistence resourcePersistence;
5349    @BeanReference(type = SubscriptionPersistence.class)
5350    protected SubscriptionPersistence subscriptionPersistence;
5351    @BeanReference(type = UserPersistence.class)
5352    protected UserPersistence userPersistence;
5353    @BeanReference(type = WorkflowInstanceLinkPersistence.class)
5354    protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
5355    @BeanReference(type = AssetCategoryPersistence.class)
5356    protected AssetCategoryPersistence assetCategoryPersistence;
5357    @BeanReference(type = AssetEntryPersistence.class)
5358    protected AssetEntryPersistence assetEntryPersistence;
5359    @BeanReference(type = AssetTagPersistence.class)
5360    protected AssetTagPersistence assetTagPersistence;
5361    @BeanReference(type = ExpandoValuePersistence.class)
5362    protected ExpandoValuePersistence expandoValuePersistence;
5363    @BeanReference(type = MBMessagePersistence.class)
5364    protected MBMessagePersistence mbMessagePersistence;
5365    @BeanReference(type = RatingsStatsPersistence.class)
5366    protected RatingsStatsPersistence ratingsStatsPersistence;
5367    private static final String _SQL_SELECT_JOURNALARTICLE = "SELECT journalArticle FROM JournalArticle journalArticle";
5368    private static final String _SQL_SELECT_JOURNALARTICLE_WHERE = "SELECT journalArticle FROM JournalArticle journalArticle WHERE ";
5369    private static final String _SQL_COUNT_JOURNALARTICLE = "SELECT COUNT(journalArticle) FROM JournalArticle journalArticle";
5370    private static final String _SQL_COUNT_JOURNALARTICLE_WHERE = "SELECT COUNT(journalArticle) FROM JournalArticle journalArticle WHERE ";
5371    private static final String _FINDER_COLUMN_UUID_UUID_1 = "journalArticle.uuid IS NULL";
5372    private static final String _FINDER_COLUMN_UUID_UUID_2 = "journalArticle.uuid = ?";
5373    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(journalArticle.uuid IS NULL OR journalArticle.uuid = ?)";
5374    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "journalArticle.uuid IS NULL AND ";
5375    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "journalArticle.uuid = ? AND ";
5376    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(journalArticle.uuid IS NULL OR journalArticle.uuid = ?) AND ";
5377    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "journalArticle.groupId = ?";
5378    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticle.groupId = ?";
5379    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "journalArticle.companyId = ?";
5380    private static final String _FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2 = "journalArticle.smallImageId = ?";
5381    private static final String _FINDER_COLUMN_R_S_RESOURCEPRIMKEY_2 = "journalArticle.resourcePrimKey = ? AND ";
5382    private static final String _FINDER_COLUMN_R_S_STATUS_2 = "journalArticle.status = ?";
5383    private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticle.groupId = ? AND ";
5384    private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticle.articleId IS NULL";
5385    private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticle.articleId = ?";
5386    private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticle.articleId IS NULL OR journalArticle.articleId = ?)";
5387    private static final String _FINDER_COLUMN_G_S_GROUPID_2 = "journalArticle.groupId = ? AND ";
5388    private static final String _FINDER_COLUMN_G_S_STRUCTUREID_1 = "journalArticle.structureId IS NULL";
5389    private static final String _FINDER_COLUMN_G_S_STRUCTUREID_2 = "journalArticle.structureId = ?";
5390    private static final String _FINDER_COLUMN_G_S_STRUCTUREID_3 = "(journalArticle.structureId IS NULL OR journalArticle.structureId = ?)";
5391    private static final String _FINDER_COLUMN_G_T_GROUPID_2 = "journalArticle.groupId = ? AND ";
5392    private static final String _FINDER_COLUMN_G_T_TEMPLATEID_1 = "journalArticle.templateId IS NULL";
5393    private static final String _FINDER_COLUMN_G_T_TEMPLATEID_2 = "journalArticle.templateId = ?";
5394    private static final String _FINDER_COLUMN_G_T_TEMPLATEID_3 = "(journalArticle.templateId IS NULL OR journalArticle.templateId = ?)";
5395    private static final String _FINDER_COLUMN_G_UT_GROUPID_2 = "journalArticle.groupId = ? AND ";
5396    private static final String _FINDER_COLUMN_G_UT_URLTITLE_1 = "journalArticle.urlTitle IS NULL";
5397    private static final String _FINDER_COLUMN_G_UT_URLTITLE_2 = "journalArticle.urlTitle = ?";
5398    private static final String _FINDER_COLUMN_G_UT_URLTITLE_3 = "(journalArticle.urlTitle IS NULL OR journalArticle.urlTitle = ?)";
5399    private static final String _FINDER_COLUMN_C_S_COMPANYID_2 = "journalArticle.companyId = ? AND ";
5400    private static final String _FINDER_COLUMN_C_S_STATUS_2 = "journalArticle.status = ?";
5401    private static final String _FINDER_COLUMN_G_A_V_GROUPID_2 = "journalArticle.groupId = ? AND ";
5402    private static final String _FINDER_COLUMN_G_A_V_ARTICLEID_1 = "journalArticle.articleId IS NULL AND ";
5403    private static final String _FINDER_COLUMN_G_A_V_ARTICLEID_2 = "journalArticle.articleId = ? AND ";
5404    private static final String _FINDER_COLUMN_G_A_V_ARTICLEID_3 = "(journalArticle.articleId IS NULL OR journalArticle.articleId = ?) AND ";
5405    private static final String _FINDER_COLUMN_G_A_V_VERSION_2 = "journalArticle.version = ?";
5406    private static final String _FINDER_COLUMN_G_A_S_GROUPID_2 = "journalArticle.groupId = ? AND ";
5407    private static final String _FINDER_COLUMN_G_A_S_ARTICLEID_1 = "journalArticle.articleId IS NULL AND ";
5408    private static final String _FINDER_COLUMN_G_A_S_ARTICLEID_2 = "journalArticle.articleId = ? AND ";
5409    private static final String _FINDER_COLUMN_G_A_S_ARTICLEID_3 = "(journalArticle.articleId IS NULL OR journalArticle.articleId = ?) AND ";
5410    private static final String _FINDER_COLUMN_G_A_S_STATUS_2 = "journalArticle.status = ?";
5411    private static final String _FINDER_COLUMN_G_UT_S_GROUPID_2 = "journalArticle.groupId = ? AND ";
5412    private static final String _FINDER_COLUMN_G_UT_S_URLTITLE_1 = "journalArticle.urlTitle IS NULL AND ";
5413    private static final String _FINDER_COLUMN_G_UT_S_URLTITLE_2 = "journalArticle.urlTitle = ? AND ";
5414    private static final String _FINDER_COLUMN_G_UT_S_URLTITLE_3 = "(journalArticle.urlTitle IS NULL OR journalArticle.urlTitle = ?) AND ";
5415    private static final String _FINDER_COLUMN_G_UT_S_STATUS_2 = "journalArticle.status = ?";
5416    private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticle.";
5417    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticle exists with the primary key ";
5418    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticle exists with the key {";
5419    private static Log _log = LogFactoryUtil.getLog(JournalArticlePersistenceImpl.class);
5420}