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