001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.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.service.ServiceContext;
022    
023    import com.liferay.portlet.journal.model.JournalArticle;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the journal article service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see JournalArticlePersistence
036     * @see JournalArticlePersistenceImpl
037     * @generated
038     */
039    public class JournalArticleUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(JournalArticle journalArticle) {
051                    getPersistence().clearCache(journalArticle);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<JournalArticle> findWithDynamicQuery(
066                    DynamicQuery dynamicQuery) throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<JournalArticle> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<JournalArticle> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static JournalArticle remove(JournalArticle journalArticle)
094                    throws SystemException {
095                    return getPersistence().remove(journalArticle);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
100             */
101            public static JournalArticle update(JournalArticle journalArticle,
102                    boolean merge) throws SystemException {
103                    return getPersistence().update(journalArticle, merge);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
108             */
109            public static JournalArticle update(JournalArticle journalArticle,
110                    boolean merge, ServiceContext serviceContext) throws SystemException {
111                    return getPersistence().update(journalArticle, merge, serviceContext);
112            }
113    
114            /**
115            * Caches the journal article in the entity cache if it is enabled.
116            *
117            * @param journalArticle the journal article to cache
118            */
119            public static void cacheResult(
120                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
121                    getPersistence().cacheResult(journalArticle);
122            }
123    
124            /**
125            * Caches the journal articles in the entity cache if it is enabled.
126            *
127            * @param journalArticles the journal articles to cache
128            */
129            public static void cacheResult(
130                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
131                    getPersistence().cacheResult(journalArticles);
132            }
133    
134            /**
135            * Creates a new journal article with the primary key.
136            *
137            * @param id the primary key for the new journal article
138            * @return the new journal article
139            */
140            public static com.liferay.portlet.journal.model.JournalArticle create(
141                    long id) {
142                    return getPersistence().create(id);
143            }
144    
145            /**
146            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
147            *
148            * @param id the primary key of the journal article to remove
149            * @return the journal article that was removed
150            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
151            * @throws SystemException if a system exception occurred
152            */
153            public static com.liferay.portlet.journal.model.JournalArticle remove(
154                    long id)
155                    throws com.liferay.portal.kernel.exception.SystemException,
156                            com.liferay.portlet.journal.NoSuchArticleException {
157                    return getPersistence().remove(id);
158            }
159    
160            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
161                    com.liferay.portlet.journal.model.JournalArticle journalArticle,
162                    boolean merge)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence().updateImpl(journalArticle, merge);
165            }
166    
167            /**
168            * Finds the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
169            *
170            * @param id the primary key of the journal article to find
171            * @return the journal article
172            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
176                    long id)
177                    throws com.liferay.portal.kernel.exception.SystemException,
178                            com.liferay.portlet.journal.NoSuchArticleException {
179                    return getPersistence().findByPrimaryKey(id);
180            }
181    
182            /**
183            * Finds the journal article with the primary key or returns <code>null</code> if it could not be found.
184            *
185            * @param id the primary key of the journal article to find
186            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
187            * @throws SystemException if a system exception occurred
188            */
189            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
190                    long id) throws com.liferay.portal.kernel.exception.SystemException {
191                    return getPersistence().fetchByPrimaryKey(id);
192            }
193    
194            /**
195            * Finds all the journal articles where uuid = &#63;.
196            *
197            * @param uuid the uuid to search with
198            * @return the matching journal articles
199            * @throws SystemException if a system exception occurred
200            */
201            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
202                    java.lang.String uuid)
203                    throws com.liferay.portal.kernel.exception.SystemException {
204                    return getPersistence().findByUuid(uuid);
205            }
206    
207            /**
208            * Finds a range of all the journal articles where uuid = &#63;.
209            *
210            * <p>
211            * 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.
212            * </p>
213            *
214            * @param uuid the uuid to search with
215            * @param start the lower bound of the range of journal articles to return
216            * @param end the upper bound of the range of journal articles to return (not inclusive)
217            * @return the range of matching journal articles
218            * @throws SystemException if a system exception occurred
219            */
220            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
221                    java.lang.String uuid, int start, int end)
222                    throws com.liferay.portal.kernel.exception.SystemException {
223                    return getPersistence().findByUuid(uuid, start, end);
224            }
225    
226            /**
227            * Finds an ordered range of all the journal articles where uuid = &#63;.
228            *
229            * <p>
230            * 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.
231            * </p>
232            *
233            * @param uuid the uuid to search with
234            * @param start the lower bound of the range of journal articles to return
235            * @param end the upper bound of the range of journal articles to return (not inclusive)
236            * @param orderByComparator the comparator to order the results by
237            * @return the ordered range of matching journal articles
238            * @throws SystemException if a system exception occurred
239            */
240            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
241                    java.lang.String uuid, int start, int end,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException {
244                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
245            }
246    
247            /**
248            * Finds the first journal article in the ordered set where uuid = &#63;.
249            *
250            * <p>
251            * 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.
252            * </p>
253            *
254            * @param uuid the uuid to search with
255            * @param orderByComparator the comparator to order the set by
256            * @return the first matching journal article
257            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
258            * @throws SystemException if a system exception occurred
259            */
260            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
261                    java.lang.String uuid,
262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
263                    throws com.liferay.portal.kernel.exception.SystemException,
264                            com.liferay.portlet.journal.NoSuchArticleException {
265                    return getPersistence().findByUuid_First(uuid, orderByComparator);
266            }
267    
268            /**
269            * Finds the last journal article in the ordered set where uuid = &#63;.
270            *
271            * <p>
272            * 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.
273            * </p>
274            *
275            * @param uuid the uuid to search with
276            * @param orderByComparator the comparator to order the set by
277            * @return the last matching journal article
278            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
282                    java.lang.String uuid,
283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
284                    throws com.liferay.portal.kernel.exception.SystemException,
285                            com.liferay.portlet.journal.NoSuchArticleException {
286                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
287            }
288    
289            /**
290            * Finds the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
291            *
292            * <p>
293            * 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.
294            * </p>
295            *
296            * @param id the primary key of the current journal article
297            * @param uuid the uuid to search with
298            * @param orderByComparator the comparator to order the set by
299            * @return the previous, current, and next journal article
300            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
301            * @throws SystemException if a system exception occurred
302            */
303            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
304                    long id, java.lang.String uuid,
305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
306                    throws com.liferay.portal.kernel.exception.SystemException,
307                            com.liferay.portlet.journal.NoSuchArticleException {
308                    return getPersistence()
309                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
310            }
311    
312            /**
313            * Finds the journal article where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
314            *
315            * @param uuid the uuid to search with
316            * @param groupId the group id to search with
317            * @return the matching journal article
318            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
319            * @throws SystemException if a system exception occurred
320            */
321            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
322                    java.lang.String uuid, long groupId)
323                    throws com.liferay.portal.kernel.exception.SystemException,
324                            com.liferay.portlet.journal.NoSuchArticleException {
325                    return getPersistence().findByUUID_G(uuid, groupId);
326            }
327    
328            /**
329            * Finds the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
330            *
331            * @param uuid the uuid to search with
332            * @param groupId the group id to search with
333            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
334            * @throws SystemException if a system exception occurred
335            */
336            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
337                    java.lang.String uuid, long groupId)
338                    throws com.liferay.portal.kernel.exception.SystemException {
339                    return getPersistence().fetchByUUID_G(uuid, groupId);
340            }
341    
342            /**
343            * Finds 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.
344            *
345            * @param uuid the uuid to search with
346            * @param groupId the group id to search with
347            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
348            * @throws SystemException if a system exception occurred
349            */
350            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
351                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
352                    throws com.liferay.portal.kernel.exception.SystemException {
353                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
354            }
355    
356            /**
357            * Finds all the journal articles where resourcePrimKey = &#63;.
358            *
359            * @param resourcePrimKey the resource prim key to search with
360            * @return the matching journal articles
361            * @throws SystemException if a system exception occurred
362            */
363            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
364                    long resourcePrimKey)
365                    throws com.liferay.portal.kernel.exception.SystemException {
366                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
367            }
368    
369            /**
370            * Finds a range of all the journal articles where resourcePrimKey = &#63;.
371            *
372            * <p>
373            * 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.
374            * </p>
375            *
376            * @param resourcePrimKey the resource prim key to search with
377            * @param start the lower bound of the range of journal articles to return
378            * @param end the upper bound of the range of journal articles to return (not inclusive)
379            * @return the range of matching journal articles
380            * @throws SystemException if a system exception occurred
381            */
382            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
383                    long resourcePrimKey, int start, int end)
384                    throws com.liferay.portal.kernel.exception.SystemException {
385                    return getPersistence()
386                                       .findByResourcePrimKey(resourcePrimKey, start, end);
387            }
388    
389            /**
390            * Finds an ordered range of all the journal articles where resourcePrimKey = &#63;.
391            *
392            * <p>
393            * 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.
394            * </p>
395            *
396            * @param resourcePrimKey the resource prim key to search with
397            * @param start the lower bound of the range of journal articles to return
398            * @param end the upper bound of the range of journal articles to return (not inclusive)
399            * @param orderByComparator the comparator to order the results by
400            * @return the ordered range of matching journal articles
401            * @throws SystemException if a system exception occurred
402            */
403            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
404                    long resourcePrimKey, int start, int end,
405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
406                    throws com.liferay.portal.kernel.exception.SystemException {
407                    return getPersistence()
408                                       .findByResourcePrimKey(resourcePrimKey, start, end,
409                            orderByComparator);
410            }
411    
412            /**
413            * Finds the first journal article in the ordered set where resourcePrimKey = &#63;.
414            *
415            * <p>
416            * 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.
417            * </p>
418            *
419            * @param resourcePrimKey the resource prim key to search with
420            * @param orderByComparator the comparator to order the set by
421            * @return the first matching journal article
422            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
423            * @throws SystemException if a system exception occurred
424            */
425            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
426                    long resourcePrimKey,
427                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
428                    throws com.liferay.portal.kernel.exception.SystemException,
429                            com.liferay.portlet.journal.NoSuchArticleException {
430                    return getPersistence()
431                                       .findByResourcePrimKey_First(resourcePrimKey,
432                            orderByComparator);
433            }
434    
435            /**
436            * Finds the last journal article in the ordered set where resourcePrimKey = &#63;.
437            *
438            * <p>
439            * 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.
440            * </p>
441            *
442            * @param resourcePrimKey the resource prim key to search with
443            * @param orderByComparator the comparator to order the set by
444            * @return the last matching journal article
445            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
449                    long resourcePrimKey,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.journal.NoSuchArticleException {
453                    return getPersistence()
454                                       .findByResourcePrimKey_Last(resourcePrimKey,
455                            orderByComparator);
456            }
457    
458            /**
459            * Finds the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
460            *
461            * <p>
462            * 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.
463            * </p>
464            *
465            * @param id the primary key of the current journal article
466            * @param resourcePrimKey the resource prim key to search with
467            * @param orderByComparator the comparator to order the set by
468            * @return the previous, current, and next journal article
469            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
470            * @throws SystemException if a system exception occurred
471            */
472            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
473                    long id, long resourcePrimKey,
474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
475                    throws com.liferay.portal.kernel.exception.SystemException,
476                            com.liferay.portlet.journal.NoSuchArticleException {
477                    return getPersistence()
478                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
479                            orderByComparator);
480            }
481    
482            /**
483            * Finds all the journal articles where groupId = &#63;.
484            *
485            * @param groupId the group id to search with
486            * @return the matching journal articles
487            * @throws SystemException if a system exception occurred
488            */
489            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
490                    long groupId)
491                    throws com.liferay.portal.kernel.exception.SystemException {
492                    return getPersistence().findByGroupId(groupId);
493            }
494    
495            /**
496            * Finds a range of all the journal articles where groupId = &#63;.
497            *
498            * <p>
499            * 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.
500            * </p>
501            *
502            * @param groupId the group id to search with
503            * @param start the lower bound of the range of journal articles to return
504            * @param end the upper bound of the range of journal articles to return (not inclusive)
505            * @return the range of matching journal articles
506            * @throws SystemException if a system exception occurred
507            */
508            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
509                    long groupId, int start, int end)
510                    throws com.liferay.portal.kernel.exception.SystemException {
511                    return getPersistence().findByGroupId(groupId, start, end);
512            }
513    
514            /**
515            * Finds an ordered range of all the journal articles where groupId = &#63;.
516            *
517            * <p>
518            * 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.
519            * </p>
520            *
521            * @param groupId the group id to search with
522            * @param start the lower bound of the range of journal articles to return
523            * @param end the upper bound of the range of journal articles to return (not inclusive)
524            * @param orderByComparator the comparator to order the results by
525            * @return the ordered range of matching journal articles
526            * @throws SystemException if a system exception occurred
527            */
528            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
529                    long groupId, int start, int end,
530                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
531                    throws com.liferay.portal.kernel.exception.SystemException {
532                    return getPersistence()
533                                       .findByGroupId(groupId, start, end, orderByComparator);
534            }
535    
536            /**
537            * Finds the first journal article in the ordered set where groupId = &#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 groupId the group id to search with
544            * @param orderByComparator the comparator to order the set by
545            * @return the first matching journal article
546            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
547            * @throws SystemException if a system exception occurred
548            */
549            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
550                    long groupId,
551                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
552                    throws com.liferay.portal.kernel.exception.SystemException,
553                            com.liferay.portlet.journal.NoSuchArticleException {
554                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
555            }
556    
557            /**
558            * Finds the last journal article in the ordered set where groupId = &#63;.
559            *
560            * <p>
561            * 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.
562            * </p>
563            *
564            * @param groupId the group id to search with
565            * @param orderByComparator the comparator to order the set by
566            * @return the last matching journal article
567            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
568            * @throws SystemException if a system exception occurred
569            */
570            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
571                    long groupId,
572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
573                    throws com.liferay.portal.kernel.exception.SystemException,
574                            com.liferay.portlet.journal.NoSuchArticleException {
575                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
576            }
577    
578            /**
579            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
580            *
581            * <p>
582            * 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.
583            * </p>
584            *
585            * @param id the primary key of the current journal article
586            * @param groupId the group id to search with
587            * @param orderByComparator the comparator to order the set by
588            * @return the previous, current, and next journal article
589            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
590            * @throws SystemException if a system exception occurred
591            */
592            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
593                    long id, long groupId,
594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
595                    throws com.liferay.portal.kernel.exception.SystemException,
596                            com.liferay.portlet.journal.NoSuchArticleException {
597                    return getPersistence()
598                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
599            }
600    
601            /**
602            * Filters by the user's permissions and finds all the journal articles where groupId = &#63;.
603            *
604            * @param groupId the group id to search with
605            * @return the matching journal articles that the user has permission to view
606            * @throws SystemException if a system exception occurred
607            */
608            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
609                    long groupId)
610                    throws com.liferay.portal.kernel.exception.SystemException {
611                    return getPersistence().filterFindByGroupId(groupId);
612            }
613    
614            /**
615            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63;.
616            *
617            * <p>
618            * 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.
619            * </p>
620            *
621            * @param groupId the group id to search with
622            * @param start the lower bound of the range of journal articles to return
623            * @param end the upper bound of the range of journal articles to return (not inclusive)
624            * @return the range of matching journal articles that the user has permission to view
625            * @throws SystemException if a system exception occurred
626            */
627            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
628                    long groupId, int start, int end)
629                    throws com.liferay.portal.kernel.exception.SystemException {
630                    return getPersistence().filterFindByGroupId(groupId, start, end);
631            }
632    
633            /**
634            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63;.
635            *
636            * <p>
637            * 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.
638            * </p>
639            *
640            * @param groupId the group id to search with
641            * @param start the lower bound of the range of journal articles to return
642            * @param end the upper bound of the range of journal articles to return (not inclusive)
643            * @param orderByComparator the comparator to order the results by
644            * @return the ordered range of matching journal articles that the user has permission to view
645            * @throws SystemException if a system exception occurred
646            */
647            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
648                    long groupId, int start, int end,
649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
650                    throws com.liferay.portal.kernel.exception.SystemException {
651                    return getPersistence()
652                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
653            }
654    
655            /**
656            * Finds all the journal articles where companyId = &#63;.
657            *
658            * @param companyId the company id to search with
659            * @return the matching journal articles
660            * @throws SystemException if a system exception occurred
661            */
662            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
663                    long companyId)
664                    throws com.liferay.portal.kernel.exception.SystemException {
665                    return getPersistence().findByCompanyId(companyId);
666            }
667    
668            /**
669            * Finds a range of all the journal articles where companyId = &#63;.
670            *
671            * <p>
672            * 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.
673            * </p>
674            *
675            * @param companyId the company id to search with
676            * @param start the lower bound of the range of journal articles to return
677            * @param end the upper bound of the range of journal articles to return (not inclusive)
678            * @return the range of matching journal articles
679            * @throws SystemException if a system exception occurred
680            */
681            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
682                    long companyId, int start, int end)
683                    throws com.liferay.portal.kernel.exception.SystemException {
684                    return getPersistence().findByCompanyId(companyId, start, end);
685            }
686    
687            /**
688            * Finds an ordered range of all the journal articles where companyId = &#63;.
689            *
690            * <p>
691            * 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.
692            * </p>
693            *
694            * @param companyId the company id to search with
695            * @param start the lower bound of the range of journal articles to return
696            * @param end the upper bound of the range of journal articles to return (not inclusive)
697            * @param orderByComparator the comparator to order the results by
698            * @return the ordered range of matching journal articles
699            * @throws SystemException if a system exception occurred
700            */
701            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
702                    long companyId, int start, int end,
703                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
704                    throws com.liferay.portal.kernel.exception.SystemException {
705                    return getPersistence()
706                                       .findByCompanyId(companyId, start, end, orderByComparator);
707            }
708    
709            /**
710            * Finds the first journal article in the ordered set where companyId = &#63;.
711            *
712            * <p>
713            * 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.
714            * </p>
715            *
716            * @param companyId the company id to search with
717            * @param orderByComparator the comparator to order the set by
718            * @return the first matching journal article
719            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
720            * @throws SystemException if a system exception occurred
721            */
722            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
723                    long companyId,
724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
725                    throws com.liferay.portal.kernel.exception.SystemException,
726                            com.liferay.portlet.journal.NoSuchArticleException {
727                    return getPersistence()
728                                       .findByCompanyId_First(companyId, orderByComparator);
729            }
730    
731            /**
732            * Finds the last journal article in the ordered set where companyId = &#63;.
733            *
734            * <p>
735            * 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.
736            * </p>
737            *
738            * @param companyId the company id to search with
739            * @param orderByComparator the comparator to order the set by
740            * @return the last matching journal article
741            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
742            * @throws SystemException if a system exception occurred
743            */
744            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
745                    long companyId,
746                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
747                    throws com.liferay.portal.kernel.exception.SystemException,
748                            com.liferay.portlet.journal.NoSuchArticleException {
749                    return getPersistence()
750                                       .findByCompanyId_Last(companyId, orderByComparator);
751            }
752    
753            /**
754            * Finds the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
755            *
756            * <p>
757            * 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.
758            * </p>
759            *
760            * @param id the primary key of the current journal article
761            * @param companyId the company id to search with
762            * @param orderByComparator the comparator to order the set by
763            * @return the previous, current, and next journal article
764            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
765            * @throws SystemException if a system exception occurred
766            */
767            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
768                    long id, long companyId,
769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
770                    throws com.liferay.portal.kernel.exception.SystemException,
771                            com.liferay.portlet.journal.NoSuchArticleException {
772                    return getPersistence()
773                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
774            }
775    
776            /**
777            * Finds all the journal articles where smallImageId = &#63;.
778            *
779            * @param smallImageId the small image id to search with
780            * @return the matching journal articles
781            * @throws SystemException if a system exception occurred
782            */
783            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
784                    long smallImageId)
785                    throws com.liferay.portal.kernel.exception.SystemException {
786                    return getPersistence().findBySmallImageId(smallImageId);
787            }
788    
789            /**
790            * Finds a range of all the journal articles where smallImageId = &#63;.
791            *
792            * <p>
793            * 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.
794            * </p>
795            *
796            * @param smallImageId the small image id to search with
797            * @param start the lower bound of the range of journal articles to return
798            * @param end the upper bound of the range of journal articles to return (not inclusive)
799            * @return the range of matching journal articles
800            * @throws SystemException if a system exception occurred
801            */
802            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
803                    long smallImageId, int start, int end)
804                    throws com.liferay.portal.kernel.exception.SystemException {
805                    return getPersistence().findBySmallImageId(smallImageId, start, end);
806            }
807    
808            /**
809            * Finds an ordered range of all the journal articles where smallImageId = &#63;.
810            *
811            * <p>
812            * 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.
813            * </p>
814            *
815            * @param smallImageId the small image id to search with
816            * @param start the lower bound of the range of journal articles to return
817            * @param end the upper bound of the range of journal articles to return (not inclusive)
818            * @param orderByComparator the comparator to order the results by
819            * @return the ordered range of matching journal articles
820            * @throws SystemException if a system exception occurred
821            */
822            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
823                    long smallImageId, int start, int end,
824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
825                    throws com.liferay.portal.kernel.exception.SystemException {
826                    return getPersistence()
827                                       .findBySmallImageId(smallImageId, start, end,
828                            orderByComparator);
829            }
830    
831            /**
832            * Finds the first journal article in the ordered set where smallImageId = &#63;.
833            *
834            * <p>
835            * 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.
836            * </p>
837            *
838            * @param smallImageId the small image id to search with
839            * @param orderByComparator the comparator to order the set by
840            * @return the first matching journal article
841            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
842            * @throws SystemException if a system exception occurred
843            */
844            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
845                    long smallImageId,
846                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
847                    throws com.liferay.portal.kernel.exception.SystemException,
848                            com.liferay.portlet.journal.NoSuchArticleException {
849                    return getPersistence()
850                                       .findBySmallImageId_First(smallImageId, orderByComparator);
851            }
852    
853            /**
854            * Finds the last journal article in the ordered set where smallImageId = &#63;.
855            *
856            * <p>
857            * 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.
858            * </p>
859            *
860            * @param smallImageId the small image id to search with
861            * @param orderByComparator the comparator to order the set by
862            * @return the last matching journal article
863            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
864            * @throws SystemException if a system exception occurred
865            */
866            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
867                    long smallImageId,
868                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
869                    throws com.liferay.portal.kernel.exception.SystemException,
870                            com.liferay.portlet.journal.NoSuchArticleException {
871                    return getPersistence()
872                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
873            }
874    
875            /**
876            * Finds the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
877            *
878            * <p>
879            * 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.
880            * </p>
881            *
882            * @param id the primary key of the current journal article
883            * @param smallImageId the small image id to search with
884            * @param orderByComparator the comparator to order the set by
885            * @return the previous, current, and next journal article
886            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
887            * @throws SystemException if a system exception occurred
888            */
889            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
890                    long id, long smallImageId,
891                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
892                    throws com.liferay.portal.kernel.exception.SystemException,
893                            com.liferay.portlet.journal.NoSuchArticleException {
894                    return getPersistence()
895                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
896                            orderByComparator);
897            }
898    
899            /**
900            * Finds all the journal articles where resourcePrimKey = &#63; and status = &#63;.
901            *
902            * @param resourcePrimKey the resource prim key to search with
903            * @param status the status to search with
904            * @return the matching journal articles
905            * @throws SystemException if a system exception occurred
906            */
907            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
908                    long resourcePrimKey, int status)
909                    throws com.liferay.portal.kernel.exception.SystemException {
910                    return getPersistence().findByR_ST(resourcePrimKey, status);
911            }
912    
913            /**
914            * Finds a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
915            *
916            * <p>
917            * 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.
918            * </p>
919            *
920            * @param resourcePrimKey the resource prim key to search with
921            * @param status the status to search with
922            * @param start the lower bound of the range of journal articles to return
923            * @param end the upper bound of the range of journal articles to return (not inclusive)
924            * @return the range of matching journal articles
925            * @throws SystemException if a system exception occurred
926            */
927            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
928                    long resourcePrimKey, int status, int start, int end)
929                    throws com.liferay.portal.kernel.exception.SystemException {
930                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
931            }
932    
933            /**
934            * Finds an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
935            *
936            * <p>
937            * 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.
938            * </p>
939            *
940            * @param resourcePrimKey the resource prim key to search with
941            * @param status the status to search with
942            * @param start the lower bound of the range of journal articles to return
943            * @param end the upper bound of the range of journal articles to return (not inclusive)
944            * @param orderByComparator the comparator to order the results by
945            * @return the ordered range of matching journal articles
946            * @throws SystemException if a system exception occurred
947            */
948            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
949                    long resourcePrimKey, int status, int start, int end,
950                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
951                    throws com.liferay.portal.kernel.exception.SystemException {
952                    return getPersistence()
953                                       .findByR_ST(resourcePrimKey, status, start, end,
954                            orderByComparator);
955            }
956    
957            /**
958            * Finds the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
959            *
960            * <p>
961            * 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.
962            * </p>
963            *
964            * @param resourcePrimKey the resource prim key to search with
965            * @param status the status to search with
966            * @param orderByComparator the comparator to order the set by
967            * @return the first matching journal article
968            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
969            * @throws SystemException if a system exception occurred
970            */
971            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
972                    long resourcePrimKey, int status,
973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
974                    throws com.liferay.portal.kernel.exception.SystemException,
975                            com.liferay.portlet.journal.NoSuchArticleException {
976                    return getPersistence()
977                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
978            }
979    
980            /**
981            * Finds the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
982            *
983            * <p>
984            * 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.
985            * </p>
986            *
987            * @param resourcePrimKey the resource prim key to search with
988            * @param status the status to search with
989            * @param orderByComparator the comparator to order the set by
990            * @return the last matching journal article
991            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
992            * @throws SystemException if a system exception occurred
993            */
994            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
995                    long resourcePrimKey, int status,
996                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
997                    throws com.liferay.portal.kernel.exception.SystemException,
998                            com.liferay.portlet.journal.NoSuchArticleException {
999                    return getPersistence()
1000                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1001            }
1002    
1003            /**
1004            * Finds the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1005            *
1006            * <p>
1007            * 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.
1008            * </p>
1009            *
1010            * @param id the primary key of the current journal article
1011            * @param resourcePrimKey the resource prim key to search with
1012            * @param status the status to search with
1013            * @param orderByComparator the comparator to order the set by
1014            * @return the previous, current, and next journal article
1015            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1016            * @throws SystemException if a system exception occurred
1017            */
1018            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1019                    long id, long resourcePrimKey, int status,
1020                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1021                    throws com.liferay.portal.kernel.exception.SystemException,
1022                            com.liferay.portlet.journal.NoSuchArticleException {
1023                    return getPersistence()
1024                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1025                            orderByComparator);
1026            }
1027    
1028            /**
1029            * Finds all the journal articles where groupId = &#63; and articleId = &#63;.
1030            *
1031            * @param groupId the group id to search with
1032            * @param articleId the article id to search with
1033            * @return the matching journal articles
1034            * @throws SystemException if a system exception occurred
1035            */
1036            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1037                    long groupId, java.lang.String articleId)
1038                    throws com.liferay.portal.kernel.exception.SystemException {
1039                    return getPersistence().findByG_A(groupId, articleId);
1040            }
1041    
1042            /**
1043            * Finds a range of all the journal articles where groupId = &#63; and articleId = &#63;.
1044            *
1045            * <p>
1046            * 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.
1047            * </p>
1048            *
1049            * @param groupId the group id to search with
1050            * @param articleId the article id to search with
1051            * @param start the lower bound of the range of journal articles to return
1052            * @param end the upper bound of the range of journal articles to return (not inclusive)
1053            * @return the range of matching journal articles
1054            * @throws SystemException if a system exception occurred
1055            */
1056            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1057                    long groupId, java.lang.String articleId, int start, int end)
1058                    throws com.liferay.portal.kernel.exception.SystemException {
1059                    return getPersistence().findByG_A(groupId, articleId, start, end);
1060            }
1061    
1062            /**
1063            * Finds an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
1064            *
1065            * <p>
1066            * 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.
1067            * </p>
1068            *
1069            * @param groupId the group id to search with
1070            * @param articleId the article id to search with
1071            * @param start the lower bound of the range of journal articles to return
1072            * @param end the upper bound of the range of journal articles to return (not inclusive)
1073            * @param orderByComparator the comparator to order the results by
1074            * @return the ordered range of matching journal articles
1075            * @throws SystemException if a system exception occurred
1076            */
1077            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1078                    long groupId, java.lang.String articleId, int start, int end,
1079                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1080                    throws com.liferay.portal.kernel.exception.SystemException {
1081                    return getPersistence()
1082                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
1083            }
1084    
1085            /**
1086            * Finds the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1087            *
1088            * <p>
1089            * 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.
1090            * </p>
1091            *
1092            * @param groupId the group id to search with
1093            * @param articleId the article id to search with
1094            * @param orderByComparator the comparator to order the set by
1095            * @return the first matching journal article
1096            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
1100                    long groupId, java.lang.String articleId,
1101                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1102                    throws com.liferay.portal.kernel.exception.SystemException,
1103                            com.liferay.portlet.journal.NoSuchArticleException {
1104                    return getPersistence()
1105                                       .findByG_A_First(groupId, articleId, orderByComparator);
1106            }
1107    
1108            /**
1109            * Finds the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1110            *
1111            * <p>
1112            * 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.
1113            * </p>
1114            *
1115            * @param groupId the group id to search with
1116            * @param articleId the article id to search with
1117            * @param orderByComparator the comparator to order the set by
1118            * @return the last matching journal article
1119            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1120            * @throws SystemException if a system exception occurred
1121            */
1122            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
1123                    long groupId, java.lang.String articleId,
1124                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1125                    throws com.liferay.portal.kernel.exception.SystemException,
1126                            com.liferay.portlet.journal.NoSuchArticleException {
1127                    return getPersistence()
1128                                       .findByG_A_Last(groupId, articleId, orderByComparator);
1129            }
1130    
1131            /**
1132            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1133            *
1134            * <p>
1135            * 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.
1136            * </p>
1137            *
1138            * @param id the primary key of the current journal article
1139            * @param groupId the group id to search with
1140            * @param articleId the article id to search with
1141            * @param orderByComparator the comparator to order the set by
1142            * @return the previous, current, and next journal article
1143            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1144            * @throws SystemException if a system exception occurred
1145            */
1146            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
1147                    long id, long groupId, java.lang.String articleId,
1148                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1149                    throws com.liferay.portal.kernel.exception.SystemException,
1150                            com.liferay.portlet.journal.NoSuchArticleException {
1151                    return getPersistence()
1152                                       .findByG_A_PrevAndNext(id, groupId, articleId,
1153                            orderByComparator);
1154            }
1155    
1156            /**
1157            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and articleId = &#63;.
1158            *
1159            * @param groupId the group id to search with
1160            * @param articleId the article id to search with
1161            * @return the matching journal articles that the user has permission to view
1162            * @throws SystemException if a system exception occurred
1163            */
1164            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1165                    long groupId, java.lang.String articleId)
1166                    throws com.liferay.portal.kernel.exception.SystemException {
1167                    return getPersistence().filterFindByG_A(groupId, articleId);
1168            }
1169    
1170            /**
1171            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and articleId = &#63;.
1172            *
1173            * <p>
1174            * 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.
1175            * </p>
1176            *
1177            * @param groupId the group id to search with
1178            * @param articleId the article id to search with
1179            * @param start the lower bound of the range of journal articles to return
1180            * @param end the upper bound of the range of journal articles to return (not inclusive)
1181            * @return the range of matching journal articles that the user has permission to view
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1185                    long groupId, java.lang.String articleId, int start, int end)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
1188            }
1189    
1190            /**
1191            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
1192            *
1193            * <p>
1194            * 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.
1195            * </p>
1196            *
1197            * @param groupId the group id to search with
1198            * @param articleId the article id to search with
1199            * @param start the lower bound of the range of journal articles to return
1200            * @param end the upper bound of the range of journal articles to return (not inclusive)
1201            * @param orderByComparator the comparator to order the results by
1202            * @return the ordered range of matching journal articles that the user has permission to view
1203            * @throws SystemException if a system exception occurred
1204            */
1205            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1206                    long groupId, java.lang.String articleId, int start, int end,
1207                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1208                    throws com.liferay.portal.kernel.exception.SystemException {
1209                    return getPersistence()
1210                                       .filterFindByG_A(groupId, articleId, start, end,
1211                            orderByComparator);
1212            }
1213    
1214            /**
1215            * Finds all the journal articles where groupId = &#63; and structureId = &#63;.
1216            *
1217            * @param groupId the group id to search with
1218            * @param structureId the structure id to search with
1219            * @return the matching journal articles
1220            * @throws SystemException if a system exception occurred
1221            */
1222            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1223                    long groupId, java.lang.String structureId)
1224                    throws com.liferay.portal.kernel.exception.SystemException {
1225                    return getPersistence().findByG_S(groupId, structureId);
1226            }
1227    
1228            /**
1229            * Finds a range of all the journal articles where groupId = &#63; and structureId = &#63;.
1230            *
1231            * <p>
1232            * 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.
1233            * </p>
1234            *
1235            * @param groupId the group id to search with
1236            * @param structureId the structure id to search with
1237            * @param start the lower bound of the range of journal articles to return
1238            * @param end the upper bound of the range of journal articles to return (not inclusive)
1239            * @return the range of matching journal articles
1240            * @throws SystemException if a system exception occurred
1241            */
1242            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1243                    long groupId, java.lang.String structureId, int start, int end)
1244                    throws com.liferay.portal.kernel.exception.SystemException {
1245                    return getPersistence().findByG_S(groupId, structureId, start, end);
1246            }
1247    
1248            /**
1249            * Finds an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
1250            *
1251            * <p>
1252            * 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.
1253            * </p>
1254            *
1255            * @param groupId the group id to search with
1256            * @param structureId the structure id to search with
1257            * @param start the lower bound of the range of journal articles to return
1258            * @param end the upper bound of the range of journal articles to return (not inclusive)
1259            * @param orderByComparator the comparator to order the results by
1260            * @return the ordered range of matching journal articles
1261            * @throws SystemException if a system exception occurred
1262            */
1263            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1264                    long groupId, java.lang.String structureId, int start, int end,
1265                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1266                    throws com.liferay.portal.kernel.exception.SystemException {
1267                    return getPersistence()
1268                                       .findByG_S(groupId, structureId, start, end,
1269                            orderByComparator);
1270            }
1271    
1272            /**
1273            * Finds the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1274            *
1275            * <p>
1276            * 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.
1277            * </p>
1278            *
1279            * @param groupId the group id to search with
1280            * @param structureId the structure id to search with
1281            * @param orderByComparator the comparator to order the set by
1282            * @return the first matching journal article
1283            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1284            * @throws SystemException if a system exception occurred
1285            */
1286            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
1287                    long groupId, java.lang.String structureId,
1288                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1289                    throws com.liferay.portal.kernel.exception.SystemException,
1290                            com.liferay.portlet.journal.NoSuchArticleException {
1291                    return getPersistence()
1292                                       .findByG_S_First(groupId, structureId, orderByComparator);
1293            }
1294    
1295            /**
1296            * Finds the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1297            *
1298            * <p>
1299            * 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.
1300            * </p>
1301            *
1302            * @param groupId the group id to search with
1303            * @param structureId the structure id to search with
1304            * @param orderByComparator the comparator to order the set by
1305            * @return the last matching journal article
1306            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1307            * @throws SystemException if a system exception occurred
1308            */
1309            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
1310                    long groupId, java.lang.String structureId,
1311                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1312                    throws com.liferay.portal.kernel.exception.SystemException,
1313                            com.liferay.portlet.journal.NoSuchArticleException {
1314                    return getPersistence()
1315                                       .findByG_S_Last(groupId, structureId, orderByComparator);
1316            }
1317    
1318            /**
1319            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1320            *
1321            * <p>
1322            * 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.
1323            * </p>
1324            *
1325            * @param id the primary key of the current journal article
1326            * @param groupId the group id to search with
1327            * @param structureId the structure id to search with
1328            * @param orderByComparator the comparator to order the set by
1329            * @return the previous, current, and next journal article
1330            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1331            * @throws SystemException if a system exception occurred
1332            */
1333            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
1334                    long id, long groupId, java.lang.String structureId,
1335                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1336                    throws com.liferay.portal.kernel.exception.SystemException,
1337                            com.liferay.portlet.journal.NoSuchArticleException {
1338                    return getPersistence()
1339                                       .findByG_S_PrevAndNext(id, groupId, structureId,
1340                            orderByComparator);
1341            }
1342    
1343            /**
1344            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and structureId = &#63;.
1345            *
1346            * @param groupId the group id to search with
1347            * @param structureId the structure id to search with
1348            * @return the matching journal articles that the user has permission to view
1349            * @throws SystemException if a system exception occurred
1350            */
1351            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1352                    long groupId, java.lang.String structureId)
1353                    throws com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence().filterFindByG_S(groupId, structureId);
1355            }
1356    
1357            /**
1358            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and structureId = &#63;.
1359            *
1360            * <p>
1361            * 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.
1362            * </p>
1363            *
1364            * @param groupId the group id to search with
1365            * @param structureId the structure id to search with
1366            * @param start the lower bound of the range of journal articles to return
1367            * @param end the upper bound of the range of journal articles to return (not inclusive)
1368            * @return the range of matching journal articles that the user has permission to view
1369            * @throws SystemException if a system exception occurred
1370            */
1371            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1372                    long groupId, java.lang.String structureId, int start, int end)
1373                    throws com.liferay.portal.kernel.exception.SystemException {
1374                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
1375            }
1376    
1377            /**
1378            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
1379            *
1380            * <p>
1381            * 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.
1382            * </p>
1383            *
1384            * @param groupId the group id to search with
1385            * @param structureId the structure id to search with
1386            * @param start the lower bound of the range of journal articles to return
1387            * @param end the upper bound of the range of journal articles to return (not inclusive)
1388            * @param orderByComparator the comparator to order the results by
1389            * @return the ordered range of matching journal articles that the user has permission to view
1390            * @throws SystemException if a system exception occurred
1391            */
1392            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1393                    long groupId, java.lang.String structureId, int start, int end,
1394                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1395                    throws com.liferay.portal.kernel.exception.SystemException {
1396                    return getPersistence()
1397                                       .filterFindByG_S(groupId, structureId, start, end,
1398                            orderByComparator);
1399            }
1400    
1401            /**
1402            * Finds all the journal articles where groupId = &#63; and templateId = &#63;.
1403            *
1404            * @param groupId the group id to search with
1405            * @param templateId the template id to search with
1406            * @return the matching journal articles
1407            * @throws SystemException if a system exception occurred
1408            */
1409            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1410                    long groupId, java.lang.String templateId)
1411                    throws com.liferay.portal.kernel.exception.SystemException {
1412                    return getPersistence().findByG_T(groupId, templateId);
1413            }
1414    
1415            /**
1416            * Finds a range of all the journal articles where groupId = &#63; and templateId = &#63;.
1417            *
1418            * <p>
1419            * 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.
1420            * </p>
1421            *
1422            * @param groupId the group id to search with
1423            * @param templateId the template id to search with
1424            * @param start the lower bound of the range of journal articles to return
1425            * @param end the upper bound of the range of journal articles to return (not inclusive)
1426            * @return the range of matching journal articles
1427            * @throws SystemException if a system exception occurred
1428            */
1429            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1430                    long groupId, java.lang.String templateId, int start, int end)
1431                    throws com.liferay.portal.kernel.exception.SystemException {
1432                    return getPersistence().findByG_T(groupId, templateId, start, end);
1433            }
1434    
1435            /**
1436            * Finds an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
1437            *
1438            * <p>
1439            * 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.
1440            * </p>
1441            *
1442            * @param groupId the group id to search with
1443            * @param templateId the template id to search with
1444            * @param start the lower bound of the range of journal articles to return
1445            * @param end the upper bound of the range of journal articles to return (not inclusive)
1446            * @param orderByComparator the comparator to order the results by
1447            * @return the ordered range of matching journal articles
1448            * @throws SystemException if a system exception occurred
1449            */
1450            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1451                    long groupId, java.lang.String templateId, int start, int end,
1452                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1453                    throws com.liferay.portal.kernel.exception.SystemException {
1454                    return getPersistence()
1455                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
1456            }
1457    
1458            /**
1459            * Finds the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1460            *
1461            * <p>
1462            * 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.
1463            * </p>
1464            *
1465            * @param groupId the group id to search with
1466            * @param templateId the template id to search with
1467            * @param orderByComparator the comparator to order the set by
1468            * @return the first matching journal article
1469            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1470            * @throws SystemException if a system exception occurred
1471            */
1472            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
1473                    long groupId, java.lang.String templateId,
1474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1475                    throws com.liferay.portal.kernel.exception.SystemException,
1476                            com.liferay.portlet.journal.NoSuchArticleException {
1477                    return getPersistence()
1478                                       .findByG_T_First(groupId, templateId, orderByComparator);
1479            }
1480    
1481            /**
1482            * Finds the last journal article in the ordered set where groupId = &#63; and templateId = &#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 groupId the group id to search with
1489            * @param templateId the template id to search with
1490            * @param orderByComparator the comparator to order the set by
1491            * @return the last matching journal article
1492            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1493            * @throws SystemException if a system exception occurred
1494            */
1495            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
1496                    long groupId, java.lang.String templateId,
1497                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1498                    throws com.liferay.portal.kernel.exception.SystemException,
1499                            com.liferay.portlet.journal.NoSuchArticleException {
1500                    return getPersistence()
1501                                       .findByG_T_Last(groupId, templateId, orderByComparator);
1502            }
1503    
1504            /**
1505            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1506            *
1507            * <p>
1508            * 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.
1509            * </p>
1510            *
1511            * @param id the primary key of the current journal article
1512            * @param groupId the group id to search with
1513            * @param templateId the template id to search with
1514            * @param orderByComparator the comparator to order the set by
1515            * @return the previous, current, and next journal article
1516            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1517            * @throws SystemException if a system exception occurred
1518            */
1519            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
1520                    long id, long groupId, java.lang.String templateId,
1521                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1522                    throws com.liferay.portal.kernel.exception.SystemException,
1523                            com.liferay.portlet.journal.NoSuchArticleException {
1524                    return getPersistence()
1525                                       .findByG_T_PrevAndNext(id, groupId, templateId,
1526                            orderByComparator);
1527            }
1528    
1529            /**
1530            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and templateId = &#63;.
1531            *
1532            * @param groupId the group id to search with
1533            * @param templateId the template id to search with
1534            * @return the matching journal articles that the user has permission to view
1535            * @throws SystemException if a system exception occurred
1536            */
1537            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1538                    long groupId, java.lang.String templateId)
1539                    throws com.liferay.portal.kernel.exception.SystemException {
1540                    return getPersistence().filterFindByG_T(groupId, templateId);
1541            }
1542    
1543            /**
1544            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and templateId = &#63;.
1545            *
1546            * <p>
1547            * 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.
1548            * </p>
1549            *
1550            * @param groupId the group id to search with
1551            * @param templateId the template id to search with
1552            * @param start the lower bound of the range of journal articles to return
1553            * @param end the upper bound of the range of journal articles to return (not inclusive)
1554            * @return the range of matching journal articles that the user has permission to view
1555            * @throws SystemException if a system exception occurred
1556            */
1557            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1558                    long groupId, java.lang.String templateId, int start, int end)
1559                    throws com.liferay.portal.kernel.exception.SystemException {
1560                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
1561            }
1562    
1563            /**
1564            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
1565            *
1566            * <p>
1567            * 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.
1568            * </p>
1569            *
1570            * @param groupId the group id to search with
1571            * @param templateId the template id to search with
1572            * @param start the lower bound of the range of journal articles to return
1573            * @param end the upper bound of the range of journal articles to return (not inclusive)
1574            * @param orderByComparator the comparator to order the results by
1575            * @return the ordered range of matching journal articles that the user has permission to view
1576            * @throws SystemException if a system exception occurred
1577            */
1578            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1579                    long groupId, java.lang.String templateId, int start, int end,
1580                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1581                    throws com.liferay.portal.kernel.exception.SystemException {
1582                    return getPersistence()
1583                                       .filterFindByG_T(groupId, templateId, start, end,
1584                            orderByComparator);
1585            }
1586    
1587            /**
1588            * Finds all the journal articles where groupId = &#63; and urlTitle = &#63;.
1589            *
1590            * @param groupId the group id to search with
1591            * @param urlTitle the url title to search with
1592            * @return the matching journal articles
1593            * @throws SystemException if a system exception occurred
1594            */
1595            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1596                    long groupId, java.lang.String urlTitle)
1597                    throws com.liferay.portal.kernel.exception.SystemException {
1598                    return getPersistence().findByG_UT(groupId, urlTitle);
1599            }
1600    
1601            /**
1602            * Finds a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1603            *
1604            * <p>
1605            * 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.
1606            * </p>
1607            *
1608            * @param groupId the group id to search with
1609            * @param urlTitle the url title to search with
1610            * @param start the lower bound of the range of journal articles to return
1611            * @param end the upper bound of the range of journal articles to return (not inclusive)
1612            * @return the range of matching journal articles
1613            * @throws SystemException if a system exception occurred
1614            */
1615            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1616                    long groupId, java.lang.String urlTitle, int start, int end)
1617                    throws com.liferay.portal.kernel.exception.SystemException {
1618                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
1619            }
1620    
1621            /**
1622            * Finds an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1623            *
1624            * <p>
1625            * 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.
1626            * </p>
1627            *
1628            * @param groupId the group id to search with
1629            * @param urlTitle the url title to search with
1630            * @param start the lower bound of the range of journal articles to return
1631            * @param end the upper bound of the range of journal articles to return (not inclusive)
1632            * @param orderByComparator the comparator to order the results by
1633            * @return the ordered range of matching journal articles
1634            * @throws SystemException if a system exception occurred
1635            */
1636            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1637                    long groupId, java.lang.String urlTitle, int start, int end,
1638                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1639                    throws com.liferay.portal.kernel.exception.SystemException {
1640                    return getPersistence()
1641                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
1642            }
1643    
1644            /**
1645            * Finds the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1646            *
1647            * <p>
1648            * 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.
1649            * </p>
1650            *
1651            * @param groupId the group id to search with
1652            * @param urlTitle the url title to search with
1653            * @param orderByComparator the comparator to order the set by
1654            * @return the first matching journal article
1655            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1656            * @throws SystemException if a system exception occurred
1657            */
1658            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
1659                    long groupId, java.lang.String urlTitle,
1660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1661                    throws com.liferay.portal.kernel.exception.SystemException,
1662                            com.liferay.portlet.journal.NoSuchArticleException {
1663                    return getPersistence()
1664                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
1665            }
1666    
1667            /**
1668            * Finds the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1669            *
1670            * <p>
1671            * 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.
1672            * </p>
1673            *
1674            * @param groupId the group id to search with
1675            * @param urlTitle the url title to search with
1676            * @param orderByComparator the comparator to order the set by
1677            * @return the last matching journal article
1678            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1679            * @throws SystemException if a system exception occurred
1680            */
1681            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
1682                    long groupId, java.lang.String urlTitle,
1683                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1684                    throws com.liferay.portal.kernel.exception.SystemException,
1685                            com.liferay.portlet.journal.NoSuchArticleException {
1686                    return getPersistence()
1687                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
1688            }
1689    
1690            /**
1691            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1692            *
1693            * <p>
1694            * 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.
1695            * </p>
1696            *
1697            * @param id the primary key of the current journal article
1698            * @param groupId the group id to search with
1699            * @param urlTitle the url title to search with
1700            * @param orderByComparator the comparator to order the set by
1701            * @return the previous, current, and next journal article
1702            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1703            * @throws SystemException if a system exception occurred
1704            */
1705            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
1706                    long id, long groupId, java.lang.String urlTitle,
1707                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1708                    throws com.liferay.portal.kernel.exception.SystemException,
1709                            com.liferay.portlet.journal.NoSuchArticleException {
1710                    return getPersistence()
1711                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
1712                            orderByComparator);
1713            }
1714    
1715            /**
1716            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and urlTitle = &#63;.
1717            *
1718            * @param groupId the group id to search with
1719            * @param urlTitle the url title to search with
1720            * @return the matching journal articles that the user has permission to view
1721            * @throws SystemException if a system exception occurred
1722            */
1723            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1724                    long groupId, java.lang.String urlTitle)
1725                    throws com.liferay.portal.kernel.exception.SystemException {
1726                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
1727            }
1728    
1729            /**
1730            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1731            *
1732            * <p>
1733            * 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.
1734            * </p>
1735            *
1736            * @param groupId the group id to search with
1737            * @param urlTitle the url title to search with
1738            * @param start the lower bound of the range of journal articles to return
1739            * @param end the upper bound of the range of journal articles to return (not inclusive)
1740            * @return the range of matching journal articles that the user has permission to view
1741            * @throws SystemException if a system exception occurred
1742            */
1743            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1744                    long groupId, java.lang.String urlTitle, int start, int end)
1745                    throws com.liferay.portal.kernel.exception.SystemException {
1746                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
1747            }
1748    
1749            /**
1750            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1751            *
1752            * <p>
1753            * 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.
1754            * </p>
1755            *
1756            * @param groupId the group id to search with
1757            * @param urlTitle the url title to search with
1758            * @param start the lower bound of the range of journal articles to return
1759            * @param end the upper bound of the range of journal articles to return (not inclusive)
1760            * @param orderByComparator the comparator to order the results by
1761            * @return the ordered range of matching journal articles that the user has permission to view
1762            * @throws SystemException if a system exception occurred
1763            */
1764            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1765                    long groupId, java.lang.String urlTitle, int start, int end,
1766                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1767                    throws com.liferay.portal.kernel.exception.SystemException {
1768                    return getPersistence()
1769                                       .filterFindByG_UT(groupId, urlTitle, start, end,
1770                            orderByComparator);
1771            }
1772    
1773            /**
1774            * Finds all the journal articles where groupId = &#63; and status = &#63;.
1775            *
1776            * @param groupId the group id to search with
1777            * @param status the status to search with
1778            * @return the matching journal articles
1779            * @throws SystemException if a system exception occurred
1780            */
1781            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
1782                    long groupId, int status)
1783                    throws com.liferay.portal.kernel.exception.SystemException {
1784                    return getPersistence().findByG_ST(groupId, status);
1785            }
1786    
1787            /**
1788            * Finds a range of all the journal articles where groupId = &#63; and status = &#63;.
1789            *
1790            * <p>
1791            * 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.
1792            * </p>
1793            *
1794            * @param groupId the group id to search with
1795            * @param status the status to search with
1796            * @param start the lower bound of the range of journal articles to return
1797            * @param end the upper bound of the range of journal articles to return (not inclusive)
1798            * @return the range of matching journal articles
1799            * @throws SystemException if a system exception occurred
1800            */
1801            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
1802                    long groupId, int status, int start, int end)
1803                    throws com.liferay.portal.kernel.exception.SystemException {
1804                    return getPersistence().findByG_ST(groupId, status, start, end);
1805            }
1806    
1807            /**
1808            * Finds an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
1809            *
1810            * <p>
1811            * 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.
1812            * </p>
1813            *
1814            * @param groupId the group id to search with
1815            * @param status the status to search with
1816            * @param start the lower bound of the range of journal articles to return
1817            * @param end the upper bound of the range of journal articles to return (not inclusive)
1818            * @param orderByComparator the comparator to order the results by
1819            * @return the ordered range of matching journal articles
1820            * @throws SystemException if a system exception occurred
1821            */
1822            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
1823                    long groupId, int status, int start, int end,
1824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1825                    throws com.liferay.portal.kernel.exception.SystemException {
1826                    return getPersistence()
1827                                       .findByG_ST(groupId, status, start, end, orderByComparator);
1828            }
1829    
1830            /**
1831            * Finds the first journal article in the ordered set where groupId = &#63; and status = &#63;.
1832            *
1833            * <p>
1834            * 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.
1835            * </p>
1836            *
1837            * @param groupId the group id to search with
1838            * @param status the status to search with
1839            * @param orderByComparator the comparator to order the set by
1840            * @return the first matching journal article
1841            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1842            * @throws SystemException if a system exception occurred
1843            */
1844            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
1845                    long groupId, int status,
1846                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1847                    throws com.liferay.portal.kernel.exception.SystemException,
1848                            com.liferay.portlet.journal.NoSuchArticleException {
1849                    return getPersistence()
1850                                       .findByG_ST_First(groupId, status, orderByComparator);
1851            }
1852    
1853            /**
1854            * Finds the last journal article in the ordered set where groupId = &#63; and status = &#63;.
1855            *
1856            * <p>
1857            * 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.
1858            * </p>
1859            *
1860            * @param groupId the group id to search with
1861            * @param status the status to search with
1862            * @param orderByComparator the comparator to order the set by
1863            * @return the last matching journal article
1864            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1865            * @throws SystemException if a system exception occurred
1866            */
1867            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
1868                    long groupId, int status,
1869                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1870                    throws com.liferay.portal.kernel.exception.SystemException,
1871                            com.liferay.portlet.journal.NoSuchArticleException {
1872                    return getPersistence()
1873                                       .findByG_ST_Last(groupId, status, orderByComparator);
1874            }
1875    
1876            /**
1877            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
1878            *
1879            * <p>
1880            * 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.
1881            * </p>
1882            *
1883            * @param id the primary key of the current journal article
1884            * @param groupId the group id to search with
1885            * @param status the status to search with
1886            * @param orderByComparator the comparator to order the set by
1887            * @return the previous, current, and next journal article
1888            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1889            * @throws SystemException if a system exception occurred
1890            */
1891            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
1892                    long id, long groupId, int status,
1893                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1894                    throws com.liferay.portal.kernel.exception.SystemException,
1895                            com.liferay.portlet.journal.NoSuchArticleException {
1896                    return getPersistence()
1897                                       .findByG_ST_PrevAndNext(id, groupId, status,
1898                            orderByComparator);
1899            }
1900    
1901            /**
1902            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and status = &#63;.
1903            *
1904            * @param groupId the group id to search with
1905            * @param status the status to search with
1906            * @return the matching journal articles that the user has permission to view
1907            * @throws SystemException if a system exception occurred
1908            */
1909            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
1910                    long groupId, int status)
1911                    throws com.liferay.portal.kernel.exception.SystemException {
1912                    return getPersistence().filterFindByG_ST(groupId, status);
1913            }
1914    
1915            /**
1916            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and status = &#63;.
1917            *
1918            * <p>
1919            * 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.
1920            * </p>
1921            *
1922            * @param groupId the group id to search with
1923            * @param status the status to search with
1924            * @param start the lower bound of the range of journal articles to return
1925            * @param end the upper bound of the range of journal articles to return (not inclusive)
1926            * @return the range of matching journal articles that the user has permission to view
1927            * @throws SystemException if a system exception occurred
1928            */
1929            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
1930                    long groupId, int status, int start, int end)
1931                    throws com.liferay.portal.kernel.exception.SystemException {
1932                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
1933            }
1934    
1935            /**
1936            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
1937            *
1938            * <p>
1939            * 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.
1940            * </p>
1941            *
1942            * @param groupId the group id to search with
1943            * @param status the status to search with
1944            * @param start the lower bound of the range of journal articles to return
1945            * @param end the upper bound of the range of journal articles to return (not inclusive)
1946            * @param orderByComparator the comparator to order the results by
1947            * @return the ordered range of matching journal articles that the user has permission to view
1948            * @throws SystemException if a system exception occurred
1949            */
1950            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
1951                    long groupId, int status, int start, int end,
1952                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1953                    throws com.liferay.portal.kernel.exception.SystemException {
1954                    return getPersistence()
1955                                       .filterFindByG_ST(groupId, status, start, end,
1956                            orderByComparator);
1957            }
1958    
1959            /**
1960            * Finds all the journal articles where companyId = &#63; and status = &#63;.
1961            *
1962            * @param companyId the company id to search with
1963            * @param status the status to search with
1964            * @return the matching journal articles
1965            * @throws SystemException if a system exception occurred
1966            */
1967            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
1968                    long companyId, int status)
1969                    throws com.liferay.portal.kernel.exception.SystemException {
1970                    return getPersistence().findByC_ST(companyId, status);
1971            }
1972    
1973            /**
1974            * Finds a range of all the journal articles where companyId = &#63; and status = &#63;.
1975            *
1976            * <p>
1977            * 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.
1978            * </p>
1979            *
1980            * @param companyId the company id to search with
1981            * @param status the status to search with
1982            * @param start the lower bound of the range of journal articles to return
1983            * @param end the upper bound of the range of journal articles to return (not inclusive)
1984            * @return the range of matching journal articles
1985            * @throws SystemException if a system exception occurred
1986            */
1987            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
1988                    long companyId, int status, int start, int end)
1989                    throws com.liferay.portal.kernel.exception.SystemException {
1990                    return getPersistence().findByC_ST(companyId, status, start, end);
1991            }
1992    
1993            /**
1994            * Finds an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
1995            *
1996            * <p>
1997            * 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.
1998            * </p>
1999            *
2000            * @param companyId the company id to search with
2001            * @param status the status to search with
2002            * @param start the lower bound of the range of journal articles to return
2003            * @param end the upper bound of the range of journal articles to return (not inclusive)
2004            * @param orderByComparator the comparator to order the results by
2005            * @return the ordered range of matching journal articles
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2009                    long companyId, int status, int start, int end,
2010                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2011                    throws com.liferay.portal.kernel.exception.SystemException {
2012                    return getPersistence()
2013                                       .findByC_ST(companyId, status, start, end, orderByComparator);
2014            }
2015    
2016            /**
2017            * Finds the first journal article in the ordered set where companyId = &#63; and status = &#63;.
2018            *
2019            * <p>
2020            * 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.
2021            * </p>
2022            *
2023            * @param companyId the company id to search with
2024            * @param status the status to search with
2025            * @param orderByComparator the comparator to order the set by
2026            * @return the first matching journal article
2027            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2028            * @throws SystemException if a system exception occurred
2029            */
2030            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
2031                    long companyId, int status,
2032                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2033                    throws com.liferay.portal.kernel.exception.SystemException,
2034                            com.liferay.portlet.journal.NoSuchArticleException {
2035                    return getPersistence()
2036                                       .findByC_ST_First(companyId, status, orderByComparator);
2037            }
2038    
2039            /**
2040            * Finds the last journal article in the ordered set where companyId = &#63; and status = &#63;.
2041            *
2042            * <p>
2043            * 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.
2044            * </p>
2045            *
2046            * @param companyId the company id to search with
2047            * @param status the status to search with
2048            * @param orderByComparator the comparator to order the set by
2049            * @return the last matching journal article
2050            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2051            * @throws SystemException if a system exception occurred
2052            */
2053            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
2054                    long companyId, int status,
2055                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2056                    throws com.liferay.portal.kernel.exception.SystemException,
2057                            com.liferay.portlet.journal.NoSuchArticleException {
2058                    return getPersistence()
2059                                       .findByC_ST_Last(companyId, status, orderByComparator);
2060            }
2061    
2062            /**
2063            * Finds the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
2064            *
2065            * <p>
2066            * 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.
2067            * </p>
2068            *
2069            * @param id the primary key of the current journal article
2070            * @param companyId the company id to search with
2071            * @param status the status to search with
2072            * @param orderByComparator the comparator to order the set by
2073            * @return the previous, current, and next journal article
2074            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2075            * @throws SystemException if a system exception occurred
2076            */
2077            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
2078                    long id, long companyId, int status,
2079                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2080                    throws com.liferay.portal.kernel.exception.SystemException,
2081                            com.liferay.portlet.journal.NoSuchArticleException {
2082                    return getPersistence()
2083                                       .findByC_ST_PrevAndNext(id, companyId, status,
2084                            orderByComparator);
2085            }
2086    
2087            /**
2088            * Finds 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.
2089            *
2090            * @param groupId the group id to search with
2091            * @param articleId the article id to search with
2092            * @param version the version to search with
2093            * @return the matching journal article
2094            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2095            * @throws SystemException if a system exception occurred
2096            */
2097            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
2098                    long groupId, java.lang.String articleId, double version)
2099                    throws com.liferay.portal.kernel.exception.SystemException,
2100                            com.liferay.portlet.journal.NoSuchArticleException {
2101                    return getPersistence().findByG_A_V(groupId, articleId, version);
2102            }
2103    
2104            /**
2105            * Finds 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.
2106            *
2107            * @param groupId the group id to search with
2108            * @param articleId the article id to search with
2109            * @param version the version to search with
2110            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
2111            * @throws SystemException if a system exception occurred
2112            */
2113            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
2114                    long groupId, java.lang.String articleId, double version)
2115                    throws com.liferay.portal.kernel.exception.SystemException {
2116                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
2117            }
2118    
2119            /**
2120            * Finds 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.
2121            *
2122            * @param groupId the group id to search with
2123            * @param articleId the article id to search with
2124            * @param version the version to search with
2125            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
2126            * @throws SystemException if a system exception occurred
2127            */
2128            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
2129                    long groupId, java.lang.String articleId, double version,
2130                    boolean retrieveFromCache)
2131                    throws com.liferay.portal.kernel.exception.SystemException {
2132                    return getPersistence()
2133                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
2134            }
2135    
2136            /**
2137            * Finds all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
2138            *
2139            * @param groupId the group id to search with
2140            * @param articleId the article id to search with
2141            * @param status the status to search with
2142            * @return the matching journal articles
2143            * @throws SystemException if a system exception occurred
2144            */
2145            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
2146                    long groupId, java.lang.String articleId, int status)
2147                    throws com.liferay.portal.kernel.exception.SystemException {
2148                    return getPersistence().findByG_A_ST(groupId, articleId, status);
2149            }
2150    
2151            /**
2152            * Finds a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
2153            *
2154            * <p>
2155            * 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.
2156            * </p>
2157            *
2158            * @param groupId the group id to search with
2159            * @param articleId the article id to search with
2160            * @param status the status to search with
2161            * @param start the lower bound of the range of journal articles to return
2162            * @param end the upper bound of the range of journal articles to return (not inclusive)
2163            * @return the range of matching journal articles
2164            * @throws SystemException if a system exception occurred
2165            */
2166            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
2167                    long groupId, java.lang.String articleId, int status, int start, int end)
2168                    throws com.liferay.portal.kernel.exception.SystemException {
2169                    return getPersistence()
2170                                       .findByG_A_ST(groupId, articleId, status, start, end);
2171            }
2172    
2173            /**
2174            * Finds an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
2175            *
2176            * <p>
2177            * 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.
2178            * </p>
2179            *
2180            * @param groupId the group id to search with
2181            * @param articleId the article id to search with
2182            * @param status the status to search with
2183            * @param start the lower bound of the range of journal articles to return
2184            * @param end the upper bound of the range of journal articles to return (not inclusive)
2185            * @param orderByComparator the comparator to order the results by
2186            * @return the ordered range of matching journal articles
2187            * @throws SystemException if a system exception occurred
2188            */
2189            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
2190                    long groupId, java.lang.String articleId, int status, int start,
2191                    int end,
2192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2193                    throws com.liferay.portal.kernel.exception.SystemException {
2194                    return getPersistence()
2195                                       .findByG_A_ST(groupId, articleId, status, start, end,
2196                            orderByComparator);
2197            }
2198    
2199            /**
2200            * Finds the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
2201            *
2202            * <p>
2203            * 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.
2204            * </p>
2205            *
2206            * @param groupId the group id to search with
2207            * @param articleId the article id to search with
2208            * @param status the status to search with
2209            * @param orderByComparator the comparator to order the set by
2210            * @return the first matching journal article
2211            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2212            * @throws SystemException if a system exception occurred
2213            */
2214            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
2215                    long groupId, java.lang.String articleId, int status,
2216                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2217                    throws com.liferay.portal.kernel.exception.SystemException,
2218                            com.liferay.portlet.journal.NoSuchArticleException {
2219                    return getPersistence()
2220                                       .findByG_A_ST_First(groupId, articleId, status,
2221                            orderByComparator);
2222            }
2223    
2224            /**
2225            * Finds the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
2226            *
2227            * <p>
2228            * 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.
2229            * </p>
2230            *
2231            * @param groupId the group id to search with
2232            * @param articleId the article id to search with
2233            * @param status the status to search with
2234            * @param orderByComparator the comparator to order the set by
2235            * @return the last matching journal article
2236            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2237            * @throws SystemException if a system exception occurred
2238            */
2239            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
2240                    long groupId, java.lang.String articleId, int status,
2241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2242                    throws com.liferay.portal.kernel.exception.SystemException,
2243                            com.liferay.portlet.journal.NoSuchArticleException {
2244                    return getPersistence()
2245                                       .findByG_A_ST_Last(groupId, articleId, status,
2246                            orderByComparator);
2247            }
2248    
2249            /**
2250            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
2251            *
2252            * <p>
2253            * 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.
2254            * </p>
2255            *
2256            * @param id the primary key of the current journal article
2257            * @param groupId the group id to search with
2258            * @param articleId the article id to search with
2259            * @param status the status to search with
2260            * @param orderByComparator the comparator to order the set by
2261            * @return the previous, current, and next journal article
2262            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2263            * @throws SystemException if a system exception occurred
2264            */
2265            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
2266                    long id, long groupId, java.lang.String articleId, int status,
2267                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2268                    throws com.liferay.portal.kernel.exception.SystemException,
2269                            com.liferay.portlet.journal.NoSuchArticleException {
2270                    return getPersistence()
2271                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
2272                            orderByComparator);
2273            }
2274    
2275            /**
2276            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
2277            *
2278            * @param groupId the group id to search with
2279            * @param articleId the article id to search with
2280            * @param status the status to search with
2281            * @return the matching journal articles that the user has permission to view
2282            * @throws SystemException if a system exception occurred
2283            */
2284            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
2285                    long groupId, java.lang.String articleId, int status)
2286                    throws com.liferay.portal.kernel.exception.SystemException {
2287                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
2288            }
2289    
2290            /**
2291            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
2292            *
2293            * <p>
2294            * 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.
2295            * </p>
2296            *
2297            * @param groupId the group id to search with
2298            * @param articleId the article id to search with
2299            * @param status the status to search with
2300            * @param start the lower bound of the range of journal articles to return
2301            * @param end the upper bound of the range of journal articles to return (not inclusive)
2302            * @return the range of matching journal articles that the user has permission to view
2303            * @throws SystemException if a system exception occurred
2304            */
2305            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
2306                    long groupId, java.lang.String articleId, int status, int start, int end)
2307                    throws com.liferay.portal.kernel.exception.SystemException {
2308                    return getPersistence()
2309                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
2310            }
2311    
2312            /**
2313            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
2314            *
2315            * <p>
2316            * 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.
2317            * </p>
2318            *
2319            * @param groupId the group id to search with
2320            * @param articleId the article id to search with
2321            * @param status the status to search with
2322            * @param start the lower bound of the range of journal articles to return
2323            * @param end the upper bound of the range of journal articles to return (not inclusive)
2324            * @param orderByComparator the comparator to order the results by
2325            * @return the ordered range of matching journal articles that the user has permission to view
2326            * @throws SystemException if a system exception occurred
2327            */
2328            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
2329                    long groupId, java.lang.String articleId, int status, int start,
2330                    int end,
2331                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2332                    throws com.liferay.portal.kernel.exception.SystemException {
2333                    return getPersistence()
2334                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
2335                            orderByComparator);
2336            }
2337    
2338            /**
2339            * Finds all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2340            *
2341            * @param groupId the group id to search with
2342            * @param urlTitle the url title to search with
2343            * @param status the status to search with
2344            * @return the 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_UT_ST(
2348                    long groupId, java.lang.String urlTitle, int status)
2349                    throws com.liferay.portal.kernel.exception.SystemException {
2350                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
2351            }
2352    
2353            /**
2354            * Finds a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#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 to search with
2361            * @param urlTitle the url title to search with
2362            * @param status the status to search with
2363            * @param start the lower bound of the range of journal articles to return
2364            * @param end the upper bound of the range of journal articles to return (not inclusive)
2365            * @return the 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_UT_ST(
2369                    long groupId, java.lang.String urlTitle, int status, int start, int end)
2370                    throws com.liferay.portal.kernel.exception.SystemException {
2371                    return getPersistence()
2372                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
2373            }
2374    
2375            /**
2376            * Finds an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2377            *
2378            * <p>
2379            * 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.
2380            * </p>
2381            *
2382            * @param groupId the group id to search with
2383            * @param urlTitle the url title to search with
2384            * @param status the status to search with
2385            * @param start the lower bound of the range of journal articles to return
2386            * @param end the upper bound of the range of journal articles to return (not inclusive)
2387            * @param orderByComparator the comparator to order the results by
2388            * @return the ordered range of matching journal articles
2389            * @throws SystemException if a system exception occurred
2390            */
2391            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
2392                    long groupId, java.lang.String urlTitle, int status, int start,
2393                    int end,
2394                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2395                    throws com.liferay.portal.kernel.exception.SystemException {
2396                    return getPersistence()
2397                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
2398                            orderByComparator);
2399            }
2400    
2401            /**
2402            * Finds the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2403            *
2404            * <p>
2405            * 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.
2406            * </p>
2407            *
2408            * @param groupId the group id to search with
2409            * @param urlTitle the url title to search with
2410            * @param status the status to search with
2411            * @param orderByComparator the comparator to order the set by
2412            * @return the first matching journal article
2413            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2414            * @throws SystemException if a system exception occurred
2415            */
2416            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
2417                    long groupId, java.lang.String urlTitle, int status,
2418                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2419                    throws com.liferay.portal.kernel.exception.SystemException,
2420                            com.liferay.portlet.journal.NoSuchArticleException {
2421                    return getPersistence()
2422                                       .findByG_UT_ST_First(groupId, urlTitle, status,
2423                            orderByComparator);
2424            }
2425    
2426            /**
2427            * Finds the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2428            *
2429            * <p>
2430            * 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.
2431            * </p>
2432            *
2433            * @param groupId the group id to search with
2434            * @param urlTitle the url title to search with
2435            * @param status the status to search with
2436            * @param orderByComparator the comparator to order the set by
2437            * @return the last matching journal article
2438            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2439            * @throws SystemException if a system exception occurred
2440            */
2441            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
2442                    long groupId, java.lang.String urlTitle, int status,
2443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2444                    throws com.liferay.portal.kernel.exception.SystemException,
2445                            com.liferay.portlet.journal.NoSuchArticleException {
2446                    return getPersistence()
2447                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
2448                            orderByComparator);
2449            }
2450    
2451            /**
2452            * Finds the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2453            *
2454            * <p>
2455            * 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.
2456            * </p>
2457            *
2458            * @param id the primary key of the current journal article
2459            * @param groupId the group id to search with
2460            * @param urlTitle the url title to search with
2461            * @param status the status to search with
2462            * @param orderByComparator the comparator to order the set by
2463            * @return the previous, current, and next journal article
2464            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2465            * @throws SystemException if a system exception occurred
2466            */
2467            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
2468                    long id, long groupId, java.lang.String urlTitle, int status,
2469                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2470                    throws com.liferay.portal.kernel.exception.SystemException,
2471                            com.liferay.portlet.journal.NoSuchArticleException {
2472                    return getPersistence()
2473                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
2474                            orderByComparator);
2475            }
2476    
2477            /**
2478            * Filters by the user's permissions and finds all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2479            *
2480            * @param groupId the group id to search with
2481            * @param urlTitle the url title to search with
2482            * @param status the status to search with
2483            * @return the matching journal articles that the user has permission to view
2484            * @throws SystemException if a system exception occurred
2485            */
2486            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
2487                    long groupId, java.lang.String urlTitle, int status)
2488                    throws com.liferay.portal.kernel.exception.SystemException {
2489                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
2490            }
2491    
2492            /**
2493            * Filters by the user's permissions and finds a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2494            *
2495            * <p>
2496            * 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.
2497            * </p>
2498            *
2499            * @param groupId the group id to search with
2500            * @param urlTitle the url title to search with
2501            * @param status the status to search with
2502            * @param start the lower bound of the range of journal articles to return
2503            * @param end the upper bound of the range of journal articles to return (not inclusive)
2504            * @return the range of matching journal articles that the user has permission to view
2505            * @throws SystemException if a system exception occurred
2506            */
2507            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
2508                    long groupId, java.lang.String urlTitle, int status, int start, int end)
2509                    throws com.liferay.portal.kernel.exception.SystemException {
2510                    return getPersistence()
2511                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
2512            }
2513    
2514            /**
2515            * Filters by the user's permissions and finds an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
2516            *
2517            * <p>
2518            * 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.
2519            * </p>
2520            *
2521            * @param groupId the group id to search with
2522            * @param urlTitle the url title to search with
2523            * @param status the status to search with
2524            * @param start the lower bound of the range of journal articles to return
2525            * @param end the upper bound of the range of journal articles to return (not inclusive)
2526            * @param orderByComparator the comparator to order the results by
2527            * @return the ordered range of matching journal articles that the user has permission to view
2528            * @throws SystemException if a system exception occurred
2529            */
2530            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
2531                    long groupId, java.lang.String urlTitle, int status, int start,
2532                    int end,
2533                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2534                    throws com.liferay.portal.kernel.exception.SystemException {
2535                    return getPersistence()
2536                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
2537                            orderByComparator);
2538            }
2539    
2540            /**
2541            * Finds all the journal articles.
2542            *
2543            * @return the journal articles
2544            * @throws SystemException if a system exception occurred
2545            */
2546            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
2547                    throws com.liferay.portal.kernel.exception.SystemException {
2548                    return getPersistence().findAll();
2549            }
2550    
2551            /**
2552            * Finds a range of all the journal articles.
2553            *
2554            * <p>
2555            * 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.
2556            * </p>
2557            *
2558            * @param start the lower bound of the range of journal articles to return
2559            * @param end the upper bound of the range of journal articles to return (not inclusive)
2560            * @return the range of journal articles
2561            * @throws SystemException if a system exception occurred
2562            */
2563            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
2564                    int start, int end)
2565                    throws com.liferay.portal.kernel.exception.SystemException {
2566                    return getPersistence().findAll(start, end);
2567            }
2568    
2569            /**
2570            * Finds an ordered range of all the journal articles.
2571            *
2572            * <p>
2573            * 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.
2574            * </p>
2575            *
2576            * @param start the lower bound of the range of journal articles to return
2577            * @param end the upper bound of the range of journal articles to return (not inclusive)
2578            * @param orderByComparator the comparator to order the results by
2579            * @return the ordered range of journal articles
2580            * @throws SystemException if a system exception occurred
2581            */
2582            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
2583                    int start, int end,
2584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2585                    throws com.liferay.portal.kernel.exception.SystemException {
2586                    return getPersistence().findAll(start, end, orderByComparator);
2587            }
2588    
2589            /**
2590            * Removes all the journal articles where uuid = &#63; from the database.
2591            *
2592            * @param uuid the uuid to search with
2593            * @throws SystemException if a system exception occurred
2594            */
2595            public static void removeByUuid(java.lang.String uuid)
2596                    throws com.liferay.portal.kernel.exception.SystemException {
2597                    getPersistence().removeByUuid(uuid);
2598            }
2599    
2600            /**
2601            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
2602            *
2603            * @param uuid the uuid to search with
2604            * @param groupId the group id to search with
2605            * @throws SystemException if a system exception occurred
2606            */
2607            public static void removeByUUID_G(java.lang.String uuid, long groupId)
2608                    throws com.liferay.portal.kernel.exception.SystemException,
2609                            com.liferay.portlet.journal.NoSuchArticleException {
2610                    getPersistence().removeByUUID_G(uuid, groupId);
2611            }
2612    
2613            /**
2614            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
2615            *
2616            * @param resourcePrimKey the resource prim key to search with
2617            * @throws SystemException if a system exception occurred
2618            */
2619            public static void removeByResourcePrimKey(long resourcePrimKey)
2620                    throws com.liferay.portal.kernel.exception.SystemException {
2621                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
2622            }
2623    
2624            /**
2625            * Removes all the journal articles where groupId = &#63; from the database.
2626            *
2627            * @param groupId the group id to search with
2628            * @throws SystemException if a system exception occurred
2629            */
2630            public static void removeByGroupId(long groupId)
2631                    throws com.liferay.portal.kernel.exception.SystemException {
2632                    getPersistence().removeByGroupId(groupId);
2633            }
2634    
2635            /**
2636            * Removes all the journal articles where companyId = &#63; from the database.
2637            *
2638            * @param companyId the company id to search with
2639            * @throws SystemException if a system exception occurred
2640            */
2641            public static void removeByCompanyId(long companyId)
2642                    throws com.liferay.portal.kernel.exception.SystemException {
2643                    getPersistence().removeByCompanyId(companyId);
2644            }
2645    
2646            /**
2647            * Removes all the journal articles where smallImageId = &#63; from the database.
2648            *
2649            * @param smallImageId the small image id to search with
2650            * @throws SystemException if a system exception occurred
2651            */
2652            public static void removeBySmallImageId(long smallImageId)
2653                    throws com.liferay.portal.kernel.exception.SystemException {
2654                    getPersistence().removeBySmallImageId(smallImageId);
2655            }
2656    
2657            /**
2658            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
2659            *
2660            * @param resourcePrimKey the resource prim key to search with
2661            * @param status the status to search with
2662            * @throws SystemException if a system exception occurred
2663            */
2664            public static void removeByR_ST(long resourcePrimKey, int status)
2665                    throws com.liferay.portal.kernel.exception.SystemException {
2666                    getPersistence().removeByR_ST(resourcePrimKey, status);
2667            }
2668    
2669            /**
2670            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2671            *
2672            * @param groupId the group id to search with
2673            * @param articleId the article id to search with
2674            * @throws SystemException if a system exception occurred
2675            */
2676            public static void removeByG_A(long groupId, java.lang.String articleId)
2677                    throws com.liferay.portal.kernel.exception.SystemException {
2678                    getPersistence().removeByG_A(groupId, articleId);
2679            }
2680    
2681            /**
2682            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
2683            *
2684            * @param groupId the group id to search with
2685            * @param structureId the structure id to search with
2686            * @throws SystemException if a system exception occurred
2687            */
2688            public static void removeByG_S(long groupId, java.lang.String structureId)
2689                    throws com.liferay.portal.kernel.exception.SystemException {
2690                    getPersistence().removeByG_S(groupId, structureId);
2691            }
2692    
2693            /**
2694            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
2695            *
2696            * @param groupId the group id to search with
2697            * @param templateId the template id to search with
2698            * @throws SystemException if a system exception occurred
2699            */
2700            public static void removeByG_T(long groupId, java.lang.String templateId)
2701                    throws com.liferay.portal.kernel.exception.SystemException {
2702                    getPersistence().removeByG_T(groupId, templateId);
2703            }
2704    
2705            /**
2706            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
2707            *
2708            * @param groupId the group id to search with
2709            * @param urlTitle the url title to search with
2710            * @throws SystemException if a system exception occurred
2711            */
2712            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
2713                    throws com.liferay.portal.kernel.exception.SystemException {
2714                    getPersistence().removeByG_UT(groupId, urlTitle);
2715            }
2716    
2717            /**
2718            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
2719            *
2720            * @param groupId the group id to search with
2721            * @param status the status to search with
2722            * @throws SystemException if a system exception occurred
2723            */
2724            public static void removeByG_ST(long groupId, int status)
2725                    throws com.liferay.portal.kernel.exception.SystemException {
2726                    getPersistence().removeByG_ST(groupId, status);
2727            }
2728    
2729            /**
2730            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
2731            *
2732            * @param companyId the company id to search with
2733            * @param status the status to search with
2734            * @throws SystemException if a system exception occurred
2735            */
2736            public static void removeByC_ST(long companyId, int status)
2737                    throws com.liferay.portal.kernel.exception.SystemException {
2738                    getPersistence().removeByC_ST(companyId, status);
2739            }
2740    
2741            /**
2742            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
2743            *
2744            * @param groupId the group id to search with
2745            * @param articleId the article id to search with
2746            * @param version the version to search with
2747            * @throws SystemException if a system exception occurred
2748            */
2749            public static void removeByG_A_V(long groupId, java.lang.String articleId,
2750                    double version)
2751                    throws com.liferay.portal.kernel.exception.SystemException,
2752                            com.liferay.portlet.journal.NoSuchArticleException {
2753                    getPersistence().removeByG_A_V(groupId, articleId, version);
2754            }
2755    
2756            /**
2757            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
2758            *
2759            * @param groupId the group id to search with
2760            * @param articleId the article id to search with
2761            * @param status the status to search with
2762            * @throws SystemException if a system exception occurred
2763            */
2764            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
2765                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2766                    getPersistence().removeByG_A_ST(groupId, articleId, status);
2767            }
2768    
2769            /**
2770            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
2771            *
2772            * @param groupId the group id to search with
2773            * @param urlTitle the url title to search with
2774            * @param status the status to search with
2775            * @throws SystemException if a system exception occurred
2776            */
2777            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
2778                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2779                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
2780            }
2781    
2782            /**
2783            * Removes all the journal articles from the database.
2784            *
2785            * @throws SystemException if a system exception occurred
2786            */
2787            public static void removeAll()
2788                    throws com.liferay.portal.kernel.exception.SystemException {
2789                    getPersistence().removeAll();
2790            }
2791    
2792            /**
2793            * Counts all the journal articles where uuid = &#63;.
2794            *
2795            * @param uuid the uuid to search with
2796            * @return the number of matching journal articles
2797            * @throws SystemException if a system exception occurred
2798            */
2799            public static int countByUuid(java.lang.String uuid)
2800                    throws com.liferay.portal.kernel.exception.SystemException {
2801                    return getPersistence().countByUuid(uuid);
2802            }
2803    
2804            /**
2805            * Counts all the journal articles where uuid = &#63; and groupId = &#63;.
2806            *
2807            * @param uuid the uuid to search with
2808            * @param groupId the group id to search with
2809            * @return the number of matching journal articles
2810            * @throws SystemException if a system exception occurred
2811            */
2812            public static int countByUUID_G(java.lang.String uuid, long groupId)
2813                    throws com.liferay.portal.kernel.exception.SystemException {
2814                    return getPersistence().countByUUID_G(uuid, groupId);
2815            }
2816    
2817            /**
2818            * Counts all the journal articles where resourcePrimKey = &#63;.
2819            *
2820            * @param resourcePrimKey the resource prim key to search with
2821            * @return the number of matching journal articles
2822            * @throws SystemException if a system exception occurred
2823            */
2824            public static int countByResourcePrimKey(long resourcePrimKey)
2825                    throws com.liferay.portal.kernel.exception.SystemException {
2826                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
2827            }
2828    
2829            /**
2830            * Counts all the journal articles where groupId = &#63;.
2831            *
2832            * @param groupId the group id to search with
2833            * @return the number of matching journal articles
2834            * @throws SystemException if a system exception occurred
2835            */
2836            public static int countByGroupId(long groupId)
2837                    throws com.liferay.portal.kernel.exception.SystemException {
2838                    return getPersistence().countByGroupId(groupId);
2839            }
2840    
2841            /**
2842            * Filters by the user's permissions and counts all the journal articles where groupId = &#63;.
2843            *
2844            * @param groupId the group id to search with
2845            * @return the number of matching journal articles that the user has permission to view
2846            * @throws SystemException if a system exception occurred
2847            */
2848            public static int filterCountByGroupId(long groupId)
2849                    throws com.liferay.portal.kernel.exception.SystemException {
2850                    return getPersistence().filterCountByGroupId(groupId);
2851            }
2852    
2853            /**
2854            * Counts all the journal articles where companyId = &#63;.
2855            *
2856            * @param companyId the company id to search with
2857            * @return the number of matching journal articles
2858            * @throws SystemException if a system exception occurred
2859            */
2860            public static int countByCompanyId(long companyId)
2861                    throws com.liferay.portal.kernel.exception.SystemException {
2862                    return getPersistence().countByCompanyId(companyId);
2863            }
2864    
2865            /**
2866            * Counts all the journal articles where smallImageId = &#63;.
2867            *
2868            * @param smallImageId the small image id to search with
2869            * @return the number of matching journal articles
2870            * @throws SystemException if a system exception occurred
2871            */
2872            public static int countBySmallImageId(long smallImageId)
2873                    throws com.liferay.portal.kernel.exception.SystemException {
2874                    return getPersistence().countBySmallImageId(smallImageId);
2875            }
2876    
2877            /**
2878            * Counts all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2879            *
2880            * @param resourcePrimKey the resource prim key to search with
2881            * @param status the status to search with
2882            * @return the number of matching journal articles
2883            * @throws SystemException if a system exception occurred
2884            */
2885            public static int countByR_ST(long resourcePrimKey, int status)
2886                    throws com.liferay.portal.kernel.exception.SystemException {
2887                    return getPersistence().countByR_ST(resourcePrimKey, status);
2888            }
2889    
2890            /**
2891            * Counts all the journal articles where groupId = &#63; and articleId = &#63;.
2892            *
2893            * @param groupId the group id to search with
2894            * @param articleId the article id to search with
2895            * @return the number of matching journal articles
2896            * @throws SystemException if a system exception occurred
2897            */
2898            public static int countByG_A(long groupId, java.lang.String articleId)
2899                    throws com.liferay.portal.kernel.exception.SystemException {
2900                    return getPersistence().countByG_A(groupId, articleId);
2901            }
2902    
2903            /**
2904            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and articleId = &#63;.
2905            *
2906            * @param groupId the group id to search with
2907            * @param articleId the article id to search with
2908            * @return the number of matching journal articles that the user has permission to view
2909            * @throws SystemException if a system exception occurred
2910            */
2911            public static int filterCountByG_A(long groupId, java.lang.String articleId)
2912                    throws com.liferay.portal.kernel.exception.SystemException {
2913                    return getPersistence().filterCountByG_A(groupId, articleId);
2914            }
2915    
2916            /**
2917            * Counts all the journal articles where groupId = &#63; and structureId = &#63;.
2918            *
2919            * @param groupId the group id to search with
2920            * @param structureId the structure id to search with
2921            * @return the number of matching journal articles
2922            * @throws SystemException if a system exception occurred
2923            */
2924            public static int countByG_S(long groupId, java.lang.String structureId)
2925                    throws com.liferay.portal.kernel.exception.SystemException {
2926                    return getPersistence().countByG_S(groupId, structureId);
2927            }
2928    
2929            /**
2930            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and structureId = &#63;.
2931            *
2932            * @param groupId the group id to search with
2933            * @param structureId the structure id to search with
2934            * @return the number of matching journal articles that the user has permission to view
2935            * @throws SystemException if a system exception occurred
2936            */
2937            public static int filterCountByG_S(long groupId,
2938                    java.lang.String structureId)
2939                    throws com.liferay.portal.kernel.exception.SystemException {
2940                    return getPersistence().filterCountByG_S(groupId, structureId);
2941            }
2942    
2943            /**
2944            * Counts all the journal articles where groupId = &#63; and templateId = &#63;.
2945            *
2946            * @param groupId the group id to search with
2947            * @param templateId the template id to search with
2948            * @return the number of matching journal articles
2949            * @throws SystemException if a system exception occurred
2950            */
2951            public static int countByG_T(long groupId, java.lang.String templateId)
2952                    throws com.liferay.portal.kernel.exception.SystemException {
2953                    return getPersistence().countByG_T(groupId, templateId);
2954            }
2955    
2956            /**
2957            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and templateId = &#63;.
2958            *
2959            * @param groupId the group id to search with
2960            * @param templateId the template id to search with
2961            * @return the number of matching journal articles that the user has permission to view
2962            * @throws SystemException if a system exception occurred
2963            */
2964            public static int filterCountByG_T(long groupId, java.lang.String templateId)
2965                    throws com.liferay.portal.kernel.exception.SystemException {
2966                    return getPersistence().filterCountByG_T(groupId, templateId);
2967            }
2968    
2969            /**
2970            * Counts all the journal articles where groupId = &#63; and urlTitle = &#63;.
2971            *
2972            * @param groupId the group id to search with
2973            * @param urlTitle the url title to search with
2974            * @return the number of matching journal articles
2975            * @throws SystemException if a system exception occurred
2976            */
2977            public static int countByG_UT(long groupId, java.lang.String urlTitle)
2978                    throws com.liferay.portal.kernel.exception.SystemException {
2979                    return getPersistence().countByG_UT(groupId, urlTitle);
2980            }
2981    
2982            /**
2983            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and urlTitle = &#63;.
2984            *
2985            * @param groupId the group id to search with
2986            * @param urlTitle the url title to search with
2987            * @return the number of matching journal articles that the user has permission to view
2988            * @throws SystemException if a system exception occurred
2989            */
2990            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
2991                    throws com.liferay.portal.kernel.exception.SystemException {
2992                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
2993            }
2994    
2995            /**
2996            * Counts all the journal articles where groupId = &#63; and status = &#63;.
2997            *
2998            * @param groupId the group id to search with
2999            * @param status the status to search with
3000            * @return the number of matching journal articles
3001            * @throws SystemException if a system exception occurred
3002            */
3003            public static int countByG_ST(long groupId, int status)
3004                    throws com.liferay.portal.kernel.exception.SystemException {
3005                    return getPersistence().countByG_ST(groupId, status);
3006            }
3007    
3008            /**
3009            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and status = &#63;.
3010            *
3011            * @param groupId the group id to search with
3012            * @param status the status to search with
3013            * @return the number of matching journal articles that the user has permission to view
3014            * @throws SystemException if a system exception occurred
3015            */
3016            public static int filterCountByG_ST(long groupId, int status)
3017                    throws com.liferay.portal.kernel.exception.SystemException {
3018                    return getPersistence().filterCountByG_ST(groupId, status);
3019            }
3020    
3021            /**
3022            * Counts all the journal articles where companyId = &#63; and status = &#63;.
3023            *
3024            * @param companyId the company id to search with
3025            * @param status the status to search with
3026            * @return the number of matching journal articles
3027            * @throws SystemException if a system exception occurred
3028            */
3029            public static int countByC_ST(long companyId, int status)
3030                    throws com.liferay.portal.kernel.exception.SystemException {
3031                    return getPersistence().countByC_ST(companyId, status);
3032            }
3033    
3034            /**
3035            * Counts all the journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
3036            *
3037            * @param groupId the group id to search with
3038            * @param articleId the article id to search with
3039            * @param version the version to search with
3040            * @return the number of matching journal articles
3041            * @throws SystemException if a system exception occurred
3042            */
3043            public static int countByG_A_V(long groupId, java.lang.String articleId,
3044                    double version)
3045                    throws com.liferay.portal.kernel.exception.SystemException {
3046                    return getPersistence().countByG_A_V(groupId, articleId, version);
3047            }
3048    
3049            /**
3050            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
3051            *
3052            * @param groupId the group id to search with
3053            * @param articleId the article id to search with
3054            * @param version the version to search with
3055            * @return the number of matching journal articles that the user has permission to view
3056            * @throws SystemException if a system exception occurred
3057            */
3058            public static int filterCountByG_A_V(long groupId,
3059                    java.lang.String articleId, double version)
3060                    throws com.liferay.portal.kernel.exception.SystemException {
3061                    return getPersistence().filterCountByG_A_V(groupId, articleId, version);
3062            }
3063    
3064            /**
3065            * Counts all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3066            *
3067            * @param groupId the group id to search with
3068            * @param articleId the article id to search with
3069            * @param status the status to search with
3070            * @return the number of matching journal articles
3071            * @throws SystemException if a system exception occurred
3072            */
3073            public static int countByG_A_ST(long groupId, java.lang.String articleId,
3074                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3075                    return getPersistence().countByG_A_ST(groupId, articleId, status);
3076            }
3077    
3078            /**
3079            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3080            *
3081            * @param groupId the group id to search with
3082            * @param articleId the article id to search with
3083            * @param status the status to search with
3084            * @return the number of matching journal articles that the user has permission to view
3085            * @throws SystemException if a system exception occurred
3086            */
3087            public static int filterCountByG_A_ST(long groupId,
3088                    java.lang.String articleId, int status)
3089                    throws com.liferay.portal.kernel.exception.SystemException {
3090                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
3091            }
3092    
3093            /**
3094            * Counts all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3095            *
3096            * @param groupId the group id to search with
3097            * @param urlTitle the url title to search with
3098            * @param status the status to search with
3099            * @return the number of matching journal articles
3100            * @throws SystemException if a system exception occurred
3101            */
3102            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
3103                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3104                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
3105            }
3106    
3107            /**
3108            * Filters by the user's permissions and counts all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3109            *
3110            * @param groupId the group id to search with
3111            * @param urlTitle the url title to search with
3112            * @param status the status to search with
3113            * @return the number of matching journal articles that the user has permission to view
3114            * @throws SystemException if a system exception occurred
3115            */
3116            public static int filterCountByG_UT_ST(long groupId,
3117                    java.lang.String urlTitle, int status)
3118                    throws com.liferay.portal.kernel.exception.SystemException {
3119                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
3120            }
3121    
3122            /**
3123            * Counts all the journal articles.
3124            *
3125            * @return the number of journal articles
3126            * @throws SystemException if a system exception occurred
3127            */
3128            public static int countAll()
3129                    throws com.liferay.portal.kernel.exception.SystemException {
3130                    return getPersistence().countAll();
3131            }
3132    
3133            public static JournalArticlePersistence getPersistence() {
3134                    if (_persistence == null) {
3135                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
3136                    }
3137    
3138                    return _persistence;
3139            }
3140    
3141            public void setPersistence(JournalArticlePersistence persistence) {
3142                    _persistence = persistence;
3143            }
3144    
3145            private static JournalArticlePersistence _persistence;
3146    }