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