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