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