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