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