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
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
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
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            * Returns 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
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            * Returns 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
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            * Returns all the journal articles where uuid = &#63;.
203            *
204            * @param uuid the uuid
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            * Returns 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
222            * @param start the lower bound of the range of journal articles
223            * @param end the upper bound of the range of journal articles (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            * Returns 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
241            * @param start the lower bound of the range of journal articles
242            * @param end the upper bound of the range of journal articles (not inclusive)
243            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
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            * Returns 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
262            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
283            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
305            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
321            *
322            * @param uuid the uuid
323            * @param groupId the group ID
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            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
337            *
338            * @param uuid the uuid
339            * @param groupId the group ID
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            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
351            *
352            * @param uuid the uuid
353            * @param groupId the group ID
354            * @param retrieveFromCache whether to use the finder cache
355            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
356            * @throws SystemException if a system exception occurred
357            */
358            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
359                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
360                    throws com.liferay.portal.kernel.exception.SystemException {
361                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
362            }
363    
364            /**
365            * Returns all the journal articles where resourcePrimKey = &#63;.
366            *
367            * @param resourcePrimKey the resource prim key
368            * @return the matching journal articles
369            * @throws SystemException if a system exception occurred
370            */
371            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
372                    long resourcePrimKey)
373                    throws com.liferay.portal.kernel.exception.SystemException {
374                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
375            }
376    
377            /**
378            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
379            *
380            * <p>
381            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
382            * </p>
383            *
384            * @param resourcePrimKey the resource prim key
385            * @param start the lower bound of the range of journal articles
386            * @param end the upper bound of the range of journal articles (not inclusive)
387            * @return the range of matching journal articles
388            * @throws SystemException if a system exception occurred
389            */
390            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
391                    long resourcePrimKey, int start, int end)
392                    throws com.liferay.portal.kernel.exception.SystemException {
393                    return getPersistence()
394                                       .findByResourcePrimKey(resourcePrimKey, start, end);
395            }
396    
397            /**
398            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
399            *
400            * <p>
401            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
402            * </p>
403            *
404            * @param resourcePrimKey the resource prim key
405            * @param start the lower bound of the range of journal articles
406            * @param end the upper bound of the range of journal articles (not inclusive)
407            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
408            * @return the ordered range of matching journal articles
409            * @throws SystemException if a system exception occurred
410            */
411            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
412                    long resourcePrimKey, int start, int end,
413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
414                    throws com.liferay.portal.kernel.exception.SystemException {
415                    return getPersistence()
416                                       .findByResourcePrimKey(resourcePrimKey, start, end,
417                            orderByComparator);
418            }
419    
420            /**
421            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
422            *
423            * <p>
424            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
425            * </p>
426            *
427            * @param resourcePrimKey the resource prim key
428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
429            * @return the first matching journal article
430            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
431            * @throws SystemException if a system exception occurred
432            */
433            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
434                    long resourcePrimKey,
435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
436                    throws com.liferay.portal.kernel.exception.SystemException,
437                            com.liferay.portlet.journal.NoSuchArticleException {
438                    return getPersistence()
439                                       .findByResourcePrimKey_First(resourcePrimKey,
440                            orderByComparator);
441            }
442    
443            /**
444            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
445            *
446            * <p>
447            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
448            * </p>
449            *
450            * @param resourcePrimKey the resource prim key
451            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
452            * @return the last matching journal article
453            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
454            * @throws SystemException if a system exception occurred
455            */
456            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
457                    long resourcePrimKey,
458                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
459                    throws com.liferay.portal.kernel.exception.SystemException,
460                            com.liferay.portlet.journal.NoSuchArticleException {
461                    return getPersistence()
462                                       .findByResourcePrimKey_Last(resourcePrimKey,
463                            orderByComparator);
464            }
465    
466            /**
467            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
468            *
469            * <p>
470            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
471            * </p>
472            *
473            * @param id the primary key of the current journal article
474            * @param resourcePrimKey the resource prim key
475            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
476            * @return the previous, current, and next journal article
477            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
478            * @throws SystemException if a system exception occurred
479            */
480            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
481                    long id, long resourcePrimKey,
482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
483                    throws com.liferay.portal.kernel.exception.SystemException,
484                            com.liferay.portlet.journal.NoSuchArticleException {
485                    return getPersistence()
486                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
487                            orderByComparator);
488            }
489    
490            /**
491            * Returns all the journal articles where groupId = &#63;.
492            *
493            * @param groupId the group ID
494            * @return the matching journal articles
495            * @throws SystemException if a system exception occurred
496            */
497            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
498                    long groupId)
499                    throws com.liferay.portal.kernel.exception.SystemException {
500                    return getPersistence().findByGroupId(groupId);
501            }
502    
503            /**
504            * Returns a range of all the journal articles where groupId = &#63;.
505            *
506            * <p>
507            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
508            * </p>
509            *
510            * @param groupId the group ID
511            * @param start the lower bound of the range of journal articles
512            * @param end the upper bound of the range of journal articles (not inclusive)
513            * @return the range of matching journal articles
514            * @throws SystemException if a system exception occurred
515            */
516            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
517                    long groupId, int start, int end)
518                    throws com.liferay.portal.kernel.exception.SystemException {
519                    return getPersistence().findByGroupId(groupId, start, end);
520            }
521    
522            /**
523            * Returns an ordered range of all the journal articles where groupId = &#63;.
524            *
525            * <p>
526            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
527            * </p>
528            *
529            * @param groupId the group ID
530            * @param start the lower bound of the range of journal articles
531            * @param end the upper bound of the range of journal articles (not inclusive)
532            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
533            * @return the ordered range of matching journal articles
534            * @throws SystemException if a system exception occurred
535            */
536            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
537                    long groupId, int start, int end,
538                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
539                    throws com.liferay.portal.kernel.exception.SystemException {
540                    return getPersistence()
541                                       .findByGroupId(groupId, start, end, orderByComparator);
542            }
543    
544            /**
545            * Returns the first journal article in the ordered set where groupId = &#63;.
546            *
547            * <p>
548            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
549            * </p>
550            *
551            * @param groupId the group ID
552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
553            * @return the first matching journal article
554            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
555            * @throws SystemException if a system exception occurred
556            */
557            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
558                    long groupId,
559                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
560                    throws com.liferay.portal.kernel.exception.SystemException,
561                            com.liferay.portlet.journal.NoSuchArticleException {
562                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
563            }
564    
565            /**
566            * Returns the last journal article in the ordered set where groupId = &#63;.
567            *
568            * <p>
569            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
570            * </p>
571            *
572            * @param groupId the group ID
573            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
574            * @return the last matching journal article
575            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
576            * @throws SystemException if a system exception occurred
577            */
578            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
579                    long groupId,
580                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
581                    throws com.liferay.portal.kernel.exception.SystemException,
582                            com.liferay.portlet.journal.NoSuchArticleException {
583                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
584            }
585    
586            /**
587            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
588            *
589            * <p>
590            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
591            * </p>
592            *
593            * @param id the primary key of the current journal article
594            * @param groupId the group ID
595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
596            * @return the previous, current, and next journal article
597            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
598            * @throws SystemException if a system exception occurred
599            */
600            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
601                    long id, long groupId,
602                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
603                    throws com.liferay.portal.kernel.exception.SystemException,
604                            com.liferay.portlet.journal.NoSuchArticleException {
605                    return getPersistence()
606                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
607            }
608    
609            /**
610            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
611            *
612            * @param groupId the group ID
613            * @return the matching journal articles that the user has permission to view
614            * @throws SystemException if a system exception occurred
615            */
616            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
617                    long groupId)
618                    throws com.liferay.portal.kernel.exception.SystemException {
619                    return getPersistence().filterFindByGroupId(groupId);
620            }
621    
622            /**
623            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
624            *
625            * <p>
626            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
627            * </p>
628            *
629            * @param groupId the group ID
630            * @param start the lower bound of the range of journal articles
631            * @param end the upper bound of the range of journal articles (not inclusive)
632            * @return the range of matching journal articles that the user has permission to view
633            * @throws SystemException if a system exception occurred
634            */
635            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
636                    long groupId, int start, int end)
637                    throws com.liferay.portal.kernel.exception.SystemException {
638                    return getPersistence().filterFindByGroupId(groupId, start, end);
639            }
640    
641            /**
642            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
643            *
644            * <p>
645            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
646            * </p>
647            *
648            * @param groupId the group ID
649            * @param start the lower bound of the range of journal articles
650            * @param end the upper bound of the range of journal articles (not inclusive)
651            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
652            * @return the ordered range of matching journal articles that the user has permission to view
653            * @throws SystemException if a system exception occurred
654            */
655            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
656                    long groupId, int start, int end,
657                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
658                    throws com.liferay.portal.kernel.exception.SystemException {
659                    return getPersistence()
660                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
661            }
662    
663            /**
664            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63;.
665            *
666            * @param id the primary key of the current journal article
667            * @param groupId the group ID
668            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
669            * @return the previous, current, and next journal article
670            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
671            * @throws SystemException if a system exception occurred
672            */
673            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
674                    long id, long groupId,
675                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
676                    throws com.liferay.portal.kernel.exception.SystemException,
677                            com.liferay.portlet.journal.NoSuchArticleException {
678                    return getPersistence()
679                                       .filterFindByGroupId_PrevAndNext(id, groupId,
680                            orderByComparator);
681            }
682    
683            /**
684            * Returns all the journal articles where companyId = &#63;.
685            *
686            * @param companyId the company ID
687            * @return the matching journal articles
688            * @throws SystemException if a system exception occurred
689            */
690            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
691                    long companyId)
692                    throws com.liferay.portal.kernel.exception.SystemException {
693                    return getPersistence().findByCompanyId(companyId);
694            }
695    
696            /**
697            * Returns a range of all the journal articles where companyId = &#63;.
698            *
699            * <p>
700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
701            * </p>
702            *
703            * @param companyId the company ID
704            * @param start the lower bound of the range of journal articles
705            * @param end the upper bound of the range of journal articles (not inclusive)
706            * @return the range of matching journal articles
707            * @throws SystemException if a system exception occurred
708            */
709            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
710                    long companyId, int start, int end)
711                    throws com.liferay.portal.kernel.exception.SystemException {
712                    return getPersistence().findByCompanyId(companyId, start, end);
713            }
714    
715            /**
716            * Returns an ordered range of all the journal articles where companyId = &#63;.
717            *
718            * <p>
719            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
720            * </p>
721            *
722            * @param companyId the company ID
723            * @param start the lower bound of the range of journal articles
724            * @param end the upper bound of the range of journal articles (not inclusive)
725            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
726            * @return the ordered range of matching journal articles
727            * @throws SystemException if a system exception occurred
728            */
729            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
730                    long companyId, int start, int end,
731                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
732                    throws com.liferay.portal.kernel.exception.SystemException {
733                    return getPersistence()
734                                       .findByCompanyId(companyId, start, end, orderByComparator);
735            }
736    
737            /**
738            * Returns the first journal article in the ordered set where companyId = &#63;.
739            *
740            * <p>
741            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
742            * </p>
743            *
744            * @param companyId the company ID
745            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
746            * @return the first matching journal article
747            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
748            * @throws SystemException if a system exception occurred
749            */
750            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
751                    long companyId,
752                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
753                    throws com.liferay.portal.kernel.exception.SystemException,
754                            com.liferay.portlet.journal.NoSuchArticleException {
755                    return getPersistence()
756                                       .findByCompanyId_First(companyId, orderByComparator);
757            }
758    
759            /**
760            * Returns the last journal article in the ordered set where companyId = &#63;.
761            *
762            * <p>
763            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
764            * </p>
765            *
766            * @param companyId the company ID
767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
768            * @return the last matching journal article
769            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
770            * @throws SystemException if a system exception occurred
771            */
772            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
773                    long companyId,
774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
775                    throws com.liferay.portal.kernel.exception.SystemException,
776                            com.liferay.portlet.journal.NoSuchArticleException {
777                    return getPersistence()
778                                       .findByCompanyId_Last(companyId, orderByComparator);
779            }
780    
781            /**
782            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
783            *
784            * <p>
785            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
786            * </p>
787            *
788            * @param id the primary key of the current journal article
789            * @param companyId the company ID
790            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
791            * @return the previous, current, and next journal article
792            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
793            * @throws SystemException if a system exception occurred
794            */
795            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
796                    long id, long companyId,
797                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
798                    throws com.liferay.portal.kernel.exception.SystemException,
799                            com.liferay.portlet.journal.NoSuchArticleException {
800                    return getPersistence()
801                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
802            }
803    
804            /**
805            * Returns all the journal articles where smallImageId = &#63;.
806            *
807            * @param smallImageId the small image ID
808            * @return the matching journal articles
809            * @throws SystemException if a system exception occurred
810            */
811            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
812                    long smallImageId)
813                    throws com.liferay.portal.kernel.exception.SystemException {
814                    return getPersistence().findBySmallImageId(smallImageId);
815            }
816    
817            /**
818            * Returns a range of all the journal articles where smallImageId = &#63;.
819            *
820            * <p>
821            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
822            * </p>
823            *
824            * @param smallImageId the small image ID
825            * @param start the lower bound of the range of journal articles
826            * @param end the upper bound of the range of journal articles (not inclusive)
827            * @return the range of matching journal articles
828            * @throws SystemException if a system exception occurred
829            */
830            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
831                    long smallImageId, int start, int end)
832                    throws com.liferay.portal.kernel.exception.SystemException {
833                    return getPersistence().findBySmallImageId(smallImageId, start, end);
834            }
835    
836            /**
837            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
838            *
839            * <p>
840            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
841            * </p>
842            *
843            * @param smallImageId the small image ID
844            * @param start the lower bound of the range of journal articles
845            * @param end the upper bound of the range of journal articles (not inclusive)
846            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
847            * @return the ordered range of matching journal articles
848            * @throws SystemException if a system exception occurred
849            */
850            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
851                    long smallImageId, int start, int end,
852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
853                    throws com.liferay.portal.kernel.exception.SystemException {
854                    return getPersistence()
855                                       .findBySmallImageId(smallImageId, start, end,
856                            orderByComparator);
857            }
858    
859            /**
860            * Returns the first journal article in the ordered set where smallImageId = &#63;.
861            *
862            * <p>
863            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
864            * </p>
865            *
866            * @param smallImageId the small image ID
867            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
868            * @return the first matching journal article
869            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
870            * @throws SystemException if a system exception occurred
871            */
872            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
873                    long smallImageId,
874                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
875                    throws com.liferay.portal.kernel.exception.SystemException,
876                            com.liferay.portlet.journal.NoSuchArticleException {
877                    return getPersistence()
878                                       .findBySmallImageId_First(smallImageId, orderByComparator);
879            }
880    
881            /**
882            * Returns the last journal article in the ordered set where smallImageId = &#63;.
883            *
884            * <p>
885            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
886            * </p>
887            *
888            * @param smallImageId the small image ID
889            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
890            * @return the last matching journal article
891            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
892            * @throws SystemException if a system exception occurred
893            */
894            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
895                    long smallImageId,
896                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
897                    throws com.liferay.portal.kernel.exception.SystemException,
898                            com.liferay.portlet.journal.NoSuchArticleException {
899                    return getPersistence()
900                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
901            }
902    
903            /**
904            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
905            *
906            * <p>
907            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
908            * </p>
909            *
910            * @param id the primary key of the current journal article
911            * @param smallImageId the small image ID
912            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
913            * @return the previous, current, and next journal article
914            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
915            * @throws SystemException if a system exception occurred
916            */
917            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
918                    long id, long smallImageId,
919                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
920                    throws com.liferay.portal.kernel.exception.SystemException,
921                            com.liferay.portlet.journal.NoSuchArticleException {
922                    return getPersistence()
923                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
924                            orderByComparator);
925            }
926    
927            /**
928            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
929            *
930            * @param resourcePrimKey the resource prim key
931            * @param status the status
932            * @return the matching journal articles
933            * @throws SystemException if a system exception occurred
934            */
935            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
936                    long resourcePrimKey, int status)
937                    throws com.liferay.portal.kernel.exception.SystemException {
938                    return getPersistence().findByR_ST(resourcePrimKey, status);
939            }
940    
941            /**
942            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
943            *
944            * <p>
945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
946            * </p>
947            *
948            * @param resourcePrimKey the resource prim key
949            * @param status the status
950            * @param start the lower bound of the range of journal articles
951            * @param end the upper bound of the range of journal articles (not inclusive)
952            * @return the range of matching journal articles
953            * @throws SystemException if a system exception occurred
954            */
955            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
956                    long resourcePrimKey, int status, int start, int end)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
959            }
960    
961            /**
962            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
963            *
964            * <p>
965            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
966            * </p>
967            *
968            * @param resourcePrimKey the resource prim key
969            * @param status the status
970            * @param start the lower bound of the range of journal articles
971            * @param end the upper bound of the range of journal articles (not inclusive)
972            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
973            * @return the ordered range of matching journal articles
974            * @throws SystemException if a system exception occurred
975            */
976            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
977                    long resourcePrimKey, int status, int start, int end,
978                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
979                    throws com.liferay.portal.kernel.exception.SystemException {
980                    return getPersistence()
981                                       .findByR_ST(resourcePrimKey, status, start, end,
982                            orderByComparator);
983            }
984    
985            /**
986            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
987            *
988            * <p>
989            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
990            * </p>
991            *
992            * @param resourcePrimKey the resource prim key
993            * @param status the status
994            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
995            * @return the first matching journal article
996            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
997            * @throws SystemException if a system exception occurred
998            */
999            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1000                    long resourcePrimKey, int status,
1001                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1002                    throws com.liferay.portal.kernel.exception.SystemException,
1003                            com.liferay.portlet.journal.NoSuchArticleException {
1004                    return getPersistence()
1005                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1006            }
1007    
1008            /**
1009            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1010            *
1011            * <p>
1012            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1013            * </p>
1014            *
1015            * @param resourcePrimKey the resource prim key
1016            * @param status the status
1017            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1018            * @return the last matching journal article
1019            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1020            * @throws SystemException if a system exception occurred
1021            */
1022            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1023                    long resourcePrimKey, int status,
1024                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1025                    throws com.liferay.portal.kernel.exception.SystemException,
1026                            com.liferay.portlet.journal.NoSuchArticleException {
1027                    return getPersistence()
1028                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1029            }
1030    
1031            /**
1032            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1033            *
1034            * <p>
1035            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1036            * </p>
1037            *
1038            * @param id the primary key of the current journal article
1039            * @param resourcePrimKey the resource prim key
1040            * @param status the status
1041            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1042            * @return the previous, current, and next journal article
1043            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1047                    long id, long resourcePrimKey, int status,
1048                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1049                    throws com.liferay.portal.kernel.exception.SystemException,
1050                            com.liferay.portlet.journal.NoSuchArticleException {
1051                    return getPersistence()
1052                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1053                            orderByComparator);
1054            }
1055    
1056            /**
1057            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
1058            *
1059            * @param groupId the group ID
1060            * @param articleId the article ID
1061            * @return the matching journal articles
1062            * @throws SystemException if a system exception occurred
1063            */
1064            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1065                    long groupId, java.lang.String articleId)
1066                    throws com.liferay.portal.kernel.exception.SystemException {
1067                    return getPersistence().findByG_A(groupId, articleId);
1068            }
1069    
1070            /**
1071            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
1072            *
1073            * <p>
1074            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1075            * </p>
1076            *
1077            * @param groupId the group ID
1078            * @param articleId the article ID
1079            * @param start the lower bound of the range of journal articles
1080            * @param end the upper bound of the range of journal articles (not inclusive)
1081            * @return the range of matching journal articles
1082            * @throws SystemException if a system exception occurred
1083            */
1084            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1085                    long groupId, java.lang.String articleId, int start, int end)
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    return getPersistence().findByG_A(groupId, articleId, start, end);
1088            }
1089    
1090            /**
1091            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
1092            *
1093            * <p>
1094            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1095            * </p>
1096            *
1097            * @param groupId the group ID
1098            * @param articleId the article ID
1099            * @param start the lower bound of the range of journal articles
1100            * @param end the upper bound of the range of journal articles (not inclusive)
1101            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1102            * @return the ordered range of matching journal articles
1103            * @throws SystemException if a system exception occurred
1104            */
1105            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1106                    long groupId, java.lang.String articleId, int start, int end,
1107                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1108                    throws com.liferay.portal.kernel.exception.SystemException {
1109                    return getPersistence()
1110                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
1111            }
1112    
1113            /**
1114            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1115            *
1116            * <p>
1117            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1118            * </p>
1119            *
1120            * @param groupId the group ID
1121            * @param articleId the article ID
1122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1123            * @return the first matching journal article
1124            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
1128                    long groupId, java.lang.String articleId,
1129                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1130                    throws com.liferay.portal.kernel.exception.SystemException,
1131                            com.liferay.portlet.journal.NoSuchArticleException {
1132                    return getPersistence()
1133                                       .findByG_A_First(groupId, articleId, orderByComparator);
1134            }
1135    
1136            /**
1137            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1138            *
1139            * <p>
1140            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1141            * </p>
1142            *
1143            * @param groupId the group ID
1144            * @param articleId the article ID
1145            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1146            * @return the last matching journal article
1147            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1148            * @throws SystemException if a system exception occurred
1149            */
1150            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
1151                    long groupId, java.lang.String articleId,
1152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1153                    throws com.liferay.portal.kernel.exception.SystemException,
1154                            com.liferay.portlet.journal.NoSuchArticleException {
1155                    return getPersistence()
1156                                       .findByG_A_Last(groupId, articleId, orderByComparator);
1157            }
1158    
1159            /**
1160            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1161            *
1162            * <p>
1163            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1164            * </p>
1165            *
1166            * @param id the primary key of the current journal article
1167            * @param groupId the group ID
1168            * @param articleId the article ID
1169            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1170            * @return the previous, current, and next journal article
1171            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1172            * @throws SystemException if a system exception occurred
1173            */
1174            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
1175                    long id, long groupId, java.lang.String articleId,
1176                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1177                    throws com.liferay.portal.kernel.exception.SystemException,
1178                            com.liferay.portlet.journal.NoSuchArticleException {
1179                    return getPersistence()
1180                                       .findByG_A_PrevAndNext(id, groupId, articleId,
1181                            orderByComparator);
1182            }
1183    
1184            /**
1185            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1186            *
1187            * @param groupId the group ID
1188            * @param articleId the article ID
1189            * @return the matching journal articles that the user has permission to view
1190            * @throws SystemException if a system exception occurred
1191            */
1192            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1193                    long groupId, java.lang.String articleId)
1194                    throws com.liferay.portal.kernel.exception.SystemException {
1195                    return getPersistence().filterFindByG_A(groupId, articleId);
1196            }
1197    
1198            /**
1199            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1200            *
1201            * <p>
1202            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1203            * </p>
1204            *
1205            * @param groupId the group ID
1206            * @param articleId the article ID
1207            * @param start the lower bound of the range of journal articles
1208            * @param end the upper bound of the range of journal articles (not inclusive)
1209            * @return the range of matching journal articles that the user has permission to view
1210            * @throws SystemException if a system exception occurred
1211            */
1212            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1213                    long groupId, java.lang.String articleId, int start, int end)
1214                    throws com.liferay.portal.kernel.exception.SystemException {
1215                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
1216            }
1217    
1218            /**
1219            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
1220            *
1221            * <p>
1222            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1223            * </p>
1224            *
1225            * @param groupId the group ID
1226            * @param articleId the article ID
1227            * @param start the lower bound of the range of journal articles
1228            * @param end the upper bound of the range of journal articles (not inclusive)
1229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1230            * @return the ordered range of matching journal articles that the user has permission to view
1231            * @throws SystemException if a system exception occurred
1232            */
1233            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1234                    long groupId, java.lang.String articleId, int start, int end,
1235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1236                    throws com.liferay.portal.kernel.exception.SystemException {
1237                    return getPersistence()
1238                                       .filterFindByG_A(groupId, articleId, start, end,
1239                            orderByComparator);
1240            }
1241    
1242            /**
1243            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1244            *
1245            * @param id the primary key of the current journal article
1246            * @param groupId the group ID
1247            * @param articleId the article ID
1248            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1249            * @return the previous, current, and next journal article
1250            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1251            * @throws SystemException if a system exception occurred
1252            */
1253            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
1254                    long id, long groupId, java.lang.String articleId,
1255                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1256                    throws com.liferay.portal.kernel.exception.SystemException,
1257                            com.liferay.portlet.journal.NoSuchArticleException {
1258                    return getPersistence()
1259                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
1260                            orderByComparator);
1261            }
1262    
1263            /**
1264            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
1265            *
1266            * @param groupId the group ID
1267            * @param urlTitle the url title
1268            * @return the matching journal articles
1269            * @throws SystemException if a system exception occurred
1270            */
1271            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1272                    long groupId, java.lang.String urlTitle)
1273                    throws com.liferay.portal.kernel.exception.SystemException {
1274                    return getPersistence().findByG_UT(groupId, urlTitle);
1275            }
1276    
1277            /**
1278            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1279            *
1280            * <p>
1281            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1282            * </p>
1283            *
1284            * @param groupId the group ID
1285            * @param urlTitle the url title
1286            * @param start the lower bound of the range of journal articles
1287            * @param end the upper bound of the range of journal articles (not inclusive)
1288            * @return the range of matching journal articles
1289            * @throws SystemException if a system exception occurred
1290            */
1291            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1292                    long groupId, java.lang.String urlTitle, int start, int end)
1293                    throws com.liferay.portal.kernel.exception.SystemException {
1294                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
1295            }
1296    
1297            /**
1298            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1299            *
1300            * <p>
1301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1302            * </p>
1303            *
1304            * @param groupId the group ID
1305            * @param urlTitle the url title
1306            * @param start the lower bound of the range of journal articles
1307            * @param end the upper bound of the range of journal articles (not inclusive)
1308            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1309            * @return the ordered range of matching journal articles
1310            * @throws SystemException if a system exception occurred
1311            */
1312            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1313                    long groupId, java.lang.String urlTitle, int start, int end,
1314                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1315                    throws com.liferay.portal.kernel.exception.SystemException {
1316                    return getPersistence()
1317                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
1318            }
1319    
1320            /**
1321            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1322            *
1323            * <p>
1324            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1325            * </p>
1326            *
1327            * @param groupId the group ID
1328            * @param urlTitle the url title
1329            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1330            * @return the first matching journal article
1331            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1332            * @throws SystemException if a system exception occurred
1333            */
1334            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
1335                    long groupId, java.lang.String urlTitle,
1336                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1337                    throws com.liferay.portal.kernel.exception.SystemException,
1338                            com.liferay.portlet.journal.NoSuchArticleException {
1339                    return getPersistence()
1340                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
1341            }
1342    
1343            /**
1344            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1345            *
1346            * <p>
1347            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1348            * </p>
1349            *
1350            * @param groupId the group ID
1351            * @param urlTitle the url title
1352            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1353            * @return the last matching journal article
1354            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1355            * @throws SystemException if a system exception occurred
1356            */
1357            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
1358                    long groupId, java.lang.String urlTitle,
1359                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1360                    throws com.liferay.portal.kernel.exception.SystemException,
1361                            com.liferay.portlet.journal.NoSuchArticleException {
1362                    return getPersistence()
1363                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
1364            }
1365    
1366            /**
1367            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1368            *
1369            * <p>
1370            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1371            * </p>
1372            *
1373            * @param id the primary key of the current journal article
1374            * @param groupId the group ID
1375            * @param urlTitle the url title
1376            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1377            * @return the previous, current, and next journal article
1378            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1379            * @throws SystemException if a system exception occurred
1380            */
1381            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
1382                    long id, long groupId, java.lang.String urlTitle,
1383                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1384                    throws com.liferay.portal.kernel.exception.SystemException,
1385                            com.liferay.portlet.journal.NoSuchArticleException {
1386                    return getPersistence()
1387                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
1388                            orderByComparator);
1389            }
1390    
1391            /**
1392            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1393            *
1394            * @param groupId the group ID
1395            * @param urlTitle the url title
1396            * @return the matching journal articles that the user has permission to view
1397            * @throws SystemException if a system exception occurred
1398            */
1399            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1400                    long groupId, java.lang.String urlTitle)
1401                    throws com.liferay.portal.kernel.exception.SystemException {
1402                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
1403            }
1404    
1405            /**
1406            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1407            *
1408            * <p>
1409            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1410            * </p>
1411            *
1412            * @param groupId the group ID
1413            * @param urlTitle the url title
1414            * @param start the lower bound of the range of journal articles
1415            * @param end the upper bound of the range of journal articles (not inclusive)
1416            * @return the range of matching journal articles that the user has permission to view
1417            * @throws SystemException if a system exception occurred
1418            */
1419            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1420                    long groupId, java.lang.String urlTitle, int start, int end)
1421                    throws com.liferay.portal.kernel.exception.SystemException {
1422                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
1423            }
1424    
1425            /**
1426            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
1427            *
1428            * <p>
1429            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1430            * </p>
1431            *
1432            * @param groupId the group ID
1433            * @param urlTitle the url title
1434            * @param start the lower bound of the range of journal articles
1435            * @param end the upper bound of the range of journal articles (not inclusive)
1436            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1437            * @return the ordered range of matching journal articles that the user has permission to view
1438            * @throws SystemException if a system exception occurred
1439            */
1440            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1441                    long groupId, java.lang.String urlTitle, int start, int end,
1442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1443                    throws com.liferay.portal.kernel.exception.SystemException {
1444                    return getPersistence()
1445                                       .filterFindByG_UT(groupId, urlTitle, start, end,
1446                            orderByComparator);
1447            }
1448    
1449            /**
1450            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1451            *
1452            * @param id the primary key of the current journal article
1453            * @param groupId the group ID
1454            * @param urlTitle the url title
1455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1456            * @return the previous, current, and next journal article
1457            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1458            * @throws SystemException if a system exception occurred
1459            */
1460            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
1461                    long id, long groupId, java.lang.String urlTitle,
1462                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1463                    throws com.liferay.portal.kernel.exception.SystemException,
1464                            com.liferay.portlet.journal.NoSuchArticleException {
1465                    return getPersistence()
1466                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
1467                            orderByComparator);
1468            }
1469    
1470            /**
1471            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
1472            *
1473            * @param groupId the group ID
1474            * @param structureId the structure ID
1475            * @return the matching journal articles
1476            * @throws SystemException if a system exception occurred
1477            */
1478            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1479                    long groupId, java.lang.String structureId)
1480                    throws com.liferay.portal.kernel.exception.SystemException {
1481                    return getPersistence().findByG_S(groupId, structureId);
1482            }
1483    
1484            /**
1485            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
1486            *
1487            * <p>
1488            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1489            * </p>
1490            *
1491            * @param groupId the group ID
1492            * @param structureId the structure ID
1493            * @param start the lower bound of the range of journal articles
1494            * @param end the upper bound of the range of journal articles (not inclusive)
1495            * @return the range of matching journal articles
1496            * @throws SystemException if a system exception occurred
1497            */
1498            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1499                    long groupId, java.lang.String structureId, int start, int end)
1500                    throws com.liferay.portal.kernel.exception.SystemException {
1501                    return getPersistence().findByG_S(groupId, structureId, start, end);
1502            }
1503    
1504            /**
1505            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
1506            *
1507            * <p>
1508            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1509            * </p>
1510            *
1511            * @param groupId the group ID
1512            * @param structureId the structure ID
1513            * @param start the lower bound of the range of journal articles
1514            * @param end the upper bound of the range of journal articles (not inclusive)
1515            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1516            * @return the ordered range of matching journal articles
1517            * @throws SystemException if a system exception occurred
1518            */
1519            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1520                    long groupId, java.lang.String structureId, int start, int end,
1521                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1522                    throws com.liferay.portal.kernel.exception.SystemException {
1523                    return getPersistence()
1524                                       .findByG_S(groupId, structureId, start, end,
1525                            orderByComparator);
1526            }
1527    
1528            /**
1529            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1530            *
1531            * <p>
1532            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1533            * </p>
1534            *
1535            * @param groupId the group ID
1536            * @param structureId the structure ID
1537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1538            * @return the first matching journal article
1539            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1540            * @throws SystemException if a system exception occurred
1541            */
1542            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
1543                    long groupId, java.lang.String structureId,
1544                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1545                    throws com.liferay.portal.kernel.exception.SystemException,
1546                            com.liferay.portlet.journal.NoSuchArticleException {
1547                    return getPersistence()
1548                                       .findByG_S_First(groupId, structureId, orderByComparator);
1549            }
1550    
1551            /**
1552            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1553            *
1554            * <p>
1555            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1556            * </p>
1557            *
1558            * @param groupId the group ID
1559            * @param structureId the structure ID
1560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1561            * @return the last matching journal article
1562            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1563            * @throws SystemException if a system exception occurred
1564            */
1565            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
1566                    long groupId, java.lang.String structureId,
1567                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1568                    throws com.liferay.portal.kernel.exception.SystemException,
1569                            com.liferay.portlet.journal.NoSuchArticleException {
1570                    return getPersistence()
1571                                       .findByG_S_Last(groupId, structureId, orderByComparator);
1572            }
1573    
1574            /**
1575            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1576            *
1577            * <p>
1578            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1579            * </p>
1580            *
1581            * @param id the primary key of the current journal article
1582            * @param groupId the group ID
1583            * @param structureId the structure ID
1584            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1585            * @return the previous, current, and next journal article
1586            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1587            * @throws SystemException if a system exception occurred
1588            */
1589            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
1590                    long id, long groupId, java.lang.String structureId,
1591                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1592                    throws com.liferay.portal.kernel.exception.SystemException,
1593                            com.liferay.portlet.journal.NoSuchArticleException {
1594                    return getPersistence()
1595                                       .findByG_S_PrevAndNext(id, groupId, structureId,
1596                            orderByComparator);
1597            }
1598    
1599            /**
1600            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1601            *
1602            * @param groupId the group ID
1603            * @param structureId the structure ID
1604            * @return the matching journal articles that the user has permission to view
1605            * @throws SystemException if a system exception occurred
1606            */
1607            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1608                    long groupId, java.lang.String structureId)
1609                    throws com.liferay.portal.kernel.exception.SystemException {
1610                    return getPersistence().filterFindByG_S(groupId, structureId);
1611            }
1612    
1613            /**
1614            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1615            *
1616            * <p>
1617            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1618            * </p>
1619            *
1620            * @param groupId the group ID
1621            * @param structureId the structure ID
1622            * @param start the lower bound of the range of journal articles
1623            * @param end the upper bound of the range of journal articles (not inclusive)
1624            * @return the range of matching journal articles that the user has permission to view
1625            * @throws SystemException if a system exception occurred
1626            */
1627            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1628                    long groupId, java.lang.String structureId, int start, int end)
1629                    throws com.liferay.portal.kernel.exception.SystemException {
1630                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
1631            }
1632    
1633            /**
1634            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
1635            *
1636            * <p>
1637            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1638            * </p>
1639            *
1640            * @param groupId the group ID
1641            * @param structureId the structure ID
1642            * @param start the lower bound of the range of journal articles
1643            * @param end the upper bound of the range of journal articles (not inclusive)
1644            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1645            * @return the ordered range of matching journal articles that the user has permission to view
1646            * @throws SystemException if a system exception occurred
1647            */
1648            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1649                    long groupId, java.lang.String structureId, int start, int end,
1650                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1651                    throws com.liferay.portal.kernel.exception.SystemException {
1652                    return getPersistence()
1653                                       .filterFindByG_S(groupId, structureId, start, end,
1654                            orderByComparator);
1655            }
1656    
1657            /**
1658            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1659            *
1660            * @param id the primary key of the current journal article
1661            * @param groupId the group ID
1662            * @param structureId the structure ID
1663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1664            * @return the previous, current, and next journal article
1665            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1666            * @throws SystemException if a system exception occurred
1667            */
1668            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
1669                    long id, long groupId, java.lang.String structureId,
1670                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1671                    throws com.liferay.portal.kernel.exception.SystemException,
1672                            com.liferay.portlet.journal.NoSuchArticleException {
1673                    return getPersistence()
1674                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
1675                            orderByComparator);
1676            }
1677    
1678            /**
1679            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
1680            *
1681            * @param groupId the group ID
1682            * @param templateId the template ID
1683            * @return the matching journal articles
1684            * @throws SystemException if a system exception occurred
1685            */
1686            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1687                    long groupId, java.lang.String templateId)
1688                    throws com.liferay.portal.kernel.exception.SystemException {
1689                    return getPersistence().findByG_T(groupId, templateId);
1690            }
1691    
1692            /**
1693            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
1694            *
1695            * <p>
1696            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1697            * </p>
1698            *
1699            * @param groupId the group ID
1700            * @param templateId the template ID
1701            * @param start the lower bound of the range of journal articles
1702            * @param end the upper bound of the range of journal articles (not inclusive)
1703            * @return the range of matching journal articles
1704            * @throws SystemException if a system exception occurred
1705            */
1706            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1707                    long groupId, java.lang.String templateId, int start, int end)
1708                    throws com.liferay.portal.kernel.exception.SystemException {
1709                    return getPersistence().findByG_T(groupId, templateId, start, end);
1710            }
1711    
1712            /**
1713            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
1714            *
1715            * <p>
1716            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1717            * </p>
1718            *
1719            * @param groupId the group ID
1720            * @param templateId the template ID
1721            * @param start the lower bound of the range of journal articles
1722            * @param end the upper bound of the range of journal articles (not inclusive)
1723            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1724            * @return the ordered range of matching journal articles
1725            * @throws SystemException if a system exception occurred
1726            */
1727            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1728                    long groupId, java.lang.String templateId, int start, int end,
1729                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1730                    throws com.liferay.portal.kernel.exception.SystemException {
1731                    return getPersistence()
1732                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
1733            }
1734    
1735            /**
1736            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1737            *
1738            * <p>
1739            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1740            * </p>
1741            *
1742            * @param groupId the group ID
1743            * @param templateId the template ID
1744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1745            * @return the first matching journal article
1746            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1747            * @throws SystemException if a system exception occurred
1748            */
1749            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
1750                    long groupId, java.lang.String templateId,
1751                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1752                    throws com.liferay.portal.kernel.exception.SystemException,
1753                            com.liferay.portlet.journal.NoSuchArticleException {
1754                    return getPersistence()
1755                                       .findByG_T_First(groupId, templateId, orderByComparator);
1756            }
1757    
1758            /**
1759            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1760            *
1761            * <p>
1762            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1763            * </p>
1764            *
1765            * @param groupId the group ID
1766            * @param templateId the template ID
1767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1768            * @return the last matching journal article
1769            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1770            * @throws SystemException if a system exception occurred
1771            */
1772            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
1773                    long groupId, java.lang.String templateId,
1774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1775                    throws com.liferay.portal.kernel.exception.SystemException,
1776                            com.liferay.portlet.journal.NoSuchArticleException {
1777                    return getPersistence()
1778                                       .findByG_T_Last(groupId, templateId, orderByComparator);
1779            }
1780    
1781            /**
1782            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1783            *
1784            * <p>
1785            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1786            * </p>
1787            *
1788            * @param id the primary key of the current journal article
1789            * @param groupId the group ID
1790            * @param templateId the template ID
1791            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1792            * @return the previous, current, and next journal article
1793            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1794            * @throws SystemException if a system exception occurred
1795            */
1796            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
1797                    long id, long groupId, java.lang.String templateId,
1798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1799                    throws com.liferay.portal.kernel.exception.SystemException,
1800                            com.liferay.portlet.journal.NoSuchArticleException {
1801                    return getPersistence()
1802                                       .findByG_T_PrevAndNext(id, groupId, templateId,
1803                            orderByComparator);
1804            }
1805    
1806            /**
1807            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
1808            *
1809            * @param groupId the group ID
1810            * @param templateId the template ID
1811            * @return the matching journal articles that the user has permission to view
1812            * @throws SystemException if a system exception occurred
1813            */
1814            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1815                    long groupId, java.lang.String templateId)
1816                    throws com.liferay.portal.kernel.exception.SystemException {
1817                    return getPersistence().filterFindByG_T(groupId, templateId);
1818            }
1819    
1820            /**
1821            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
1822            *
1823            * <p>
1824            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1825            * </p>
1826            *
1827            * @param groupId the group ID
1828            * @param templateId the template ID
1829            * @param start the lower bound of the range of journal articles
1830            * @param end the upper bound of the range of journal articles (not inclusive)
1831            * @return the range of matching journal articles that the user has permission to view
1832            * @throws SystemException if a system exception occurred
1833            */
1834            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1835                    long groupId, java.lang.String templateId, int start, int end)
1836                    throws com.liferay.portal.kernel.exception.SystemException {
1837                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
1838            }
1839    
1840            /**
1841            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
1842            *
1843            * <p>
1844            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1845            * </p>
1846            *
1847            * @param groupId the group ID
1848            * @param templateId the template ID
1849            * @param start the lower bound of the range of journal articles
1850            * @param end the upper bound of the range of journal articles (not inclusive)
1851            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1852            * @return the ordered range of matching journal articles that the user has permission to view
1853            * @throws SystemException if a system exception occurred
1854            */
1855            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1856                    long groupId, java.lang.String templateId, int start, int end,
1857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1858                    throws com.liferay.portal.kernel.exception.SystemException {
1859                    return getPersistence()
1860                                       .filterFindByG_T(groupId, templateId, start, end,
1861                            orderByComparator);
1862            }
1863    
1864            /**
1865            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
1866            *
1867            * @param id the primary key of the current journal article
1868            * @param groupId the group ID
1869            * @param templateId the template ID
1870            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1871            * @return the previous, current, and next journal article
1872            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1873            * @throws SystemException if a system exception occurred
1874            */
1875            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
1876                    long id, long groupId, java.lang.String templateId,
1877                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1878                    throws com.liferay.portal.kernel.exception.SystemException,
1879                            com.liferay.portlet.journal.NoSuchArticleException {
1880                    return getPersistence()
1881                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
1882                            orderByComparator);
1883            }
1884    
1885            /**
1886            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
1887            *
1888            * @param groupId the group ID
1889            * @param layoutUuid the layout uuid
1890            * @return the matching journal articles
1891            * @throws SystemException if a system exception occurred
1892            */
1893            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
1894                    long groupId, java.lang.String layoutUuid)
1895                    throws com.liferay.portal.kernel.exception.SystemException {
1896                    return getPersistence().findByG_L(groupId, layoutUuid);
1897            }
1898    
1899            /**
1900            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
1901            *
1902            * <p>
1903            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1904            * </p>
1905            *
1906            * @param groupId the group ID
1907            * @param layoutUuid the layout uuid
1908            * @param start the lower bound of the range of journal articles
1909            * @param end the upper bound of the range of journal articles (not inclusive)
1910            * @return the range of matching journal articles
1911            * @throws SystemException if a system exception occurred
1912            */
1913            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
1914                    long groupId, java.lang.String layoutUuid, int start, int end)
1915                    throws com.liferay.portal.kernel.exception.SystemException {
1916                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
1917            }
1918    
1919            /**
1920            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
1921            *
1922            * <p>
1923            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1924            * </p>
1925            *
1926            * @param groupId the group ID
1927            * @param layoutUuid the layout uuid
1928            * @param start the lower bound of the range of journal articles
1929            * @param end the upper bound of the range of journal articles (not inclusive)
1930            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1931            * @return the ordered range of matching journal articles
1932            * @throws SystemException if a system exception occurred
1933            */
1934            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
1935                    long groupId, java.lang.String layoutUuid, int start, int end,
1936                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1937                    throws com.liferay.portal.kernel.exception.SystemException {
1938                    return getPersistence()
1939                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
1940            }
1941    
1942            /**
1943            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
1944            *
1945            * <p>
1946            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1947            * </p>
1948            *
1949            * @param groupId the group ID
1950            * @param layoutUuid the layout uuid
1951            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1952            * @return the first matching journal article
1953            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1954            * @throws SystemException if a system exception occurred
1955            */
1956            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
1957                    long groupId, java.lang.String layoutUuid,
1958                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1959                    throws com.liferay.portal.kernel.exception.SystemException,
1960                            com.liferay.portlet.journal.NoSuchArticleException {
1961                    return getPersistence()
1962                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
1963            }
1964    
1965            /**
1966            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
1967            *
1968            * <p>
1969            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1970            * </p>
1971            *
1972            * @param groupId the group ID
1973            * @param layoutUuid the layout uuid
1974            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1975            * @return the last matching journal article
1976            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1977            * @throws SystemException if a system exception occurred
1978            */
1979            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
1980                    long groupId, java.lang.String layoutUuid,
1981                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1982                    throws com.liferay.portal.kernel.exception.SystemException,
1983                            com.liferay.portlet.journal.NoSuchArticleException {
1984                    return getPersistence()
1985                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
1986            }
1987    
1988            /**
1989            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
1990            *
1991            * <p>
1992            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1993            * </p>
1994            *
1995            * @param id the primary key of the current journal article
1996            * @param groupId the group ID
1997            * @param layoutUuid the layout uuid
1998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1999            * @return the previous, current, and next journal article
2000            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2001            * @throws SystemException if a system exception occurred
2002            */
2003            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
2004                    long id, long groupId, java.lang.String layoutUuid,
2005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2006                    throws com.liferay.portal.kernel.exception.SystemException,
2007                            com.liferay.portlet.journal.NoSuchArticleException {
2008                    return getPersistence()
2009                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
2010                            orderByComparator);
2011            }
2012    
2013            /**
2014            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2015            *
2016            * @param groupId the group ID
2017            * @param layoutUuid the layout uuid
2018            * @return the matching journal articles that the user has permission to view
2019            * @throws SystemException if a system exception occurred
2020            */
2021            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2022                    long groupId, java.lang.String layoutUuid)
2023                    throws com.liferay.portal.kernel.exception.SystemException {
2024                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
2025            }
2026    
2027            /**
2028            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2029            *
2030            * <p>
2031            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2032            * </p>
2033            *
2034            * @param groupId the group ID
2035            * @param layoutUuid the layout uuid
2036            * @param start the lower bound of the range of journal articles
2037            * @param end the upper bound of the range of journal articles (not inclusive)
2038            * @return the range of matching journal articles that the user has permission to view
2039            * @throws SystemException if a system exception occurred
2040            */
2041            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2042                    long groupId, java.lang.String layoutUuid, int start, int end)
2043                    throws com.liferay.portal.kernel.exception.SystemException {
2044                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
2045            }
2046    
2047            /**
2048            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
2049            *
2050            * <p>
2051            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2052            * </p>
2053            *
2054            * @param groupId the group ID
2055            * @param layoutUuid the layout uuid
2056            * @param start the lower bound of the range of journal articles
2057            * @param end the upper bound of the range of journal articles (not inclusive)
2058            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2059            * @return the ordered range of matching journal articles that the user has permission to view
2060            * @throws SystemException if a system exception occurred
2061            */
2062            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2063                    long groupId, java.lang.String layoutUuid, int start, int end,
2064                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2065                    throws com.liferay.portal.kernel.exception.SystemException {
2066                    return getPersistence()
2067                                       .filterFindByG_L(groupId, layoutUuid, start, end,
2068                            orderByComparator);
2069            }
2070    
2071            /**
2072            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2073            *
2074            * @param id the primary key of the current journal article
2075            * @param groupId the group ID
2076            * @param layoutUuid the layout uuid
2077            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2078            * @return the previous, current, and next journal article
2079            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2080            * @throws SystemException if a system exception occurred
2081            */
2082            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
2083                    long id, long groupId, java.lang.String layoutUuid,
2084                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2085                    throws com.liferay.portal.kernel.exception.SystemException,
2086                            com.liferay.portlet.journal.NoSuchArticleException {
2087                    return getPersistence()
2088                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
2089                            orderByComparator);
2090            }
2091    
2092            /**
2093            * Returns all the journal articles where groupId = &#63; and status = &#63;.
2094            *
2095            * @param groupId the group ID
2096            * @param status the status
2097            * @return the matching journal articles
2098            * @throws SystemException if a system exception occurred
2099            */
2100            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2101                    long groupId, int status)
2102                    throws com.liferay.portal.kernel.exception.SystemException {
2103                    return getPersistence().findByG_ST(groupId, status);
2104            }
2105    
2106            /**
2107            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
2108            *
2109            * <p>
2110            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2111            * </p>
2112            *
2113            * @param groupId the group ID
2114            * @param status the status
2115            * @param start the lower bound of the range of journal articles
2116            * @param end the upper bound of the range of journal articles (not inclusive)
2117            * @return the range of matching journal articles
2118            * @throws SystemException if a system exception occurred
2119            */
2120            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2121                    long groupId, int status, int start, int end)
2122                    throws com.liferay.portal.kernel.exception.SystemException {
2123                    return getPersistence().findByG_ST(groupId, status, start, end);
2124            }
2125    
2126            /**
2127            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
2128            *
2129            * <p>
2130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2131            * </p>
2132            *
2133            * @param groupId the group ID
2134            * @param status the status
2135            * @param start the lower bound of the range of journal articles
2136            * @param end the upper bound of the range of journal articles (not inclusive)
2137            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2138            * @return the ordered range of matching journal articles
2139            * @throws SystemException if a system exception occurred
2140            */
2141            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2142                    long groupId, int status, int start, int end,
2143                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2144                    throws com.liferay.portal.kernel.exception.SystemException {
2145                    return getPersistence()
2146                                       .findByG_ST(groupId, status, start, end, orderByComparator);
2147            }
2148    
2149            /**
2150            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#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 groupId the group ID
2157            * @param status the status
2158            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2159            * @return the first matching journal article
2160            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2161            * @throws SystemException if a system exception occurred
2162            */
2163            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
2164                    long groupId, int status,
2165                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2166                    throws com.liferay.portal.kernel.exception.SystemException,
2167                            com.liferay.portlet.journal.NoSuchArticleException {
2168                    return getPersistence()
2169                                       .findByG_ST_First(groupId, status, orderByComparator);
2170            }
2171    
2172            /**
2173            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#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 groupId the group ID
2180            * @param status the status
2181            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2182            * @return the last 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 findByG_ST_Last(
2187                    long groupId, int status,
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                                       .findByG_ST_Last(groupId, status, orderByComparator);
2193            }
2194    
2195            /**
2196            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#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 id the primary key of the current journal article
2203            * @param groupId the group ID
2204            * @param status the status
2205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2206            * @return the previous, current, and next journal article
2207            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2208            * @throws SystemException if a system exception occurred
2209            */
2210            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
2211                    long id, long groupId, int status,
2212                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2213                    throws com.liferay.portal.kernel.exception.SystemException,
2214                            com.liferay.portlet.journal.NoSuchArticleException {
2215                    return getPersistence()
2216                                       .findByG_ST_PrevAndNext(id, groupId, status,
2217                            orderByComparator);
2218            }
2219    
2220            /**
2221            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2222            *
2223            * @param groupId the group ID
2224            * @param status the status
2225            * @return the matching journal articles that the user has permission to view
2226            * @throws SystemException if a system exception occurred
2227            */
2228            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2229                    long groupId, int status)
2230                    throws com.liferay.portal.kernel.exception.SystemException {
2231                    return getPersistence().filterFindByG_ST(groupId, status);
2232            }
2233    
2234            /**
2235            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2236            *
2237            * <p>
2238            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2239            * </p>
2240            *
2241            * @param groupId the group ID
2242            * @param status the status
2243            * @param start the lower bound of the range of journal articles
2244            * @param end the upper bound of the range of journal articles (not inclusive)
2245            * @return the range of matching journal articles that the user has permission to view
2246            * @throws SystemException if a system exception occurred
2247            */
2248            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2249                    long groupId, int status, int start, int end)
2250                    throws com.liferay.portal.kernel.exception.SystemException {
2251                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
2252            }
2253    
2254            /**
2255            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
2256            *
2257            * <p>
2258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2259            * </p>
2260            *
2261            * @param groupId the group ID
2262            * @param status the status
2263            * @param start the lower bound of the range of journal articles
2264            * @param end the upper bound of the range of journal articles (not inclusive)
2265            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2266            * @return the ordered range of matching journal articles that the user has permission to view
2267            * @throws SystemException if a system exception occurred
2268            */
2269            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2270                    long groupId, int status, int start, int end,
2271                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2272                    throws com.liferay.portal.kernel.exception.SystemException {
2273                    return getPersistence()
2274                                       .filterFindByG_ST(groupId, status, start, end,
2275                            orderByComparator);
2276            }
2277    
2278            /**
2279            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2280            *
2281            * @param id the primary key of the current journal article
2282            * @param groupId the group ID
2283            * @param status the status
2284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2285            * @return the previous, current, and next journal article
2286            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2287            * @throws SystemException if a system exception occurred
2288            */
2289            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
2290                    long id, long groupId, int status,
2291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2292                    throws com.liferay.portal.kernel.exception.SystemException,
2293                            com.liferay.portlet.journal.NoSuchArticleException {
2294                    return getPersistence()
2295                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
2296                            orderByComparator);
2297            }
2298    
2299            /**
2300            * Returns all the journal articles where companyId = &#63; and version = &#63;.
2301            *
2302            * @param companyId the company ID
2303            * @param version the version
2304            * @return the matching journal articles
2305            * @throws SystemException if a system exception occurred
2306            */
2307            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2308                    long companyId, double version)
2309                    throws com.liferay.portal.kernel.exception.SystemException {
2310                    return getPersistence().findByC_V(companyId, version);
2311            }
2312    
2313            /**
2314            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
2315            *
2316            * <p>
2317            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2318            * </p>
2319            *
2320            * @param companyId the company ID
2321            * @param version the version
2322            * @param start the lower bound of the range of journal articles
2323            * @param end the upper bound of the range of journal articles (not inclusive)
2324            * @return the range of matching journal articles
2325            * @throws SystemException if a system exception occurred
2326            */
2327            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2328                    long companyId, double version, int start, int end)
2329                    throws com.liferay.portal.kernel.exception.SystemException {
2330                    return getPersistence().findByC_V(companyId, version, start, end);
2331            }
2332    
2333            /**
2334            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
2335            *
2336            * <p>
2337            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2338            * </p>
2339            *
2340            * @param companyId the company ID
2341            * @param version the version
2342            * @param start the lower bound of the range of journal articles
2343            * @param end the upper bound of the range of journal articles (not inclusive)
2344            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2345            * @return the ordered range of matching journal articles
2346            * @throws SystemException if a system exception occurred
2347            */
2348            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2349                    long companyId, double version, int start, int end,
2350                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2351                    throws com.liferay.portal.kernel.exception.SystemException {
2352                    return getPersistence()
2353                                       .findByC_V(companyId, version, start, end, orderByComparator);
2354            }
2355    
2356            /**
2357            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
2358            *
2359            * <p>
2360            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2361            * </p>
2362            *
2363            * @param companyId the company ID
2364            * @param version the version
2365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2366            * @return the first matching journal article
2367            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2368            * @throws SystemException if a system exception occurred
2369            */
2370            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
2371                    long companyId, double version,
2372                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2373                    throws com.liferay.portal.kernel.exception.SystemException,
2374                            com.liferay.portlet.journal.NoSuchArticleException {
2375                    return getPersistence()
2376                                       .findByC_V_First(companyId, version, orderByComparator);
2377            }
2378    
2379            /**
2380            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
2381            *
2382            * <p>
2383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2384            * </p>
2385            *
2386            * @param companyId the company ID
2387            * @param version the version
2388            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2389            * @return the last matching journal article
2390            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2391            * @throws SystemException if a system exception occurred
2392            */
2393            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
2394                    long companyId, double version,
2395                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2396                    throws com.liferay.portal.kernel.exception.SystemException,
2397                            com.liferay.portlet.journal.NoSuchArticleException {
2398                    return getPersistence()
2399                                       .findByC_V_Last(companyId, version, orderByComparator);
2400            }
2401    
2402            /**
2403            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
2404            *
2405            * <p>
2406            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2407            * </p>
2408            *
2409            * @param id the primary key of the current journal article
2410            * @param companyId the company ID
2411            * @param version the version
2412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2413            * @return the previous, current, and next journal article
2414            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2415            * @throws SystemException if a system exception occurred
2416            */
2417            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
2418                    long id, long companyId, double version,
2419                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2420                    throws com.liferay.portal.kernel.exception.SystemException,
2421                            com.liferay.portlet.journal.NoSuchArticleException {
2422                    return getPersistence()
2423                                       .findByC_V_PrevAndNext(id, companyId, version,
2424                            orderByComparator);
2425            }
2426    
2427            /**
2428            * Returns all the journal articles where companyId = &#63; and status = &#63;.
2429            *
2430            * @param companyId the company ID
2431            * @param status the status
2432            * @return the matching journal articles
2433            * @throws SystemException if a system exception occurred
2434            */
2435            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2436                    long companyId, int status)
2437                    throws com.liferay.portal.kernel.exception.SystemException {
2438                    return getPersistence().findByC_ST(companyId, status);
2439            }
2440    
2441            /**
2442            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
2443            *
2444            * <p>
2445            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2446            * </p>
2447            *
2448            * @param companyId the company ID
2449            * @param status the status
2450            * @param start the lower bound of the range of journal articles
2451            * @param end the upper bound of the range of journal articles (not inclusive)
2452            * @return the range of matching journal articles
2453            * @throws SystemException if a system exception occurred
2454            */
2455            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2456                    long companyId, int status, int start, int end)
2457                    throws com.liferay.portal.kernel.exception.SystemException {
2458                    return getPersistence().findByC_ST(companyId, status, start, end);
2459            }
2460    
2461            /**
2462            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
2463            *
2464            * <p>
2465            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2466            * </p>
2467            *
2468            * @param companyId the company ID
2469            * @param status the status
2470            * @param start the lower bound of the range of journal articles
2471            * @param end the upper bound of the range of journal articles (not inclusive)
2472            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2473            * @return the ordered range of matching journal articles
2474            * @throws SystemException if a system exception occurred
2475            */
2476            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2477                    long companyId, int status, int start, int end,
2478                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2479                    throws com.liferay.portal.kernel.exception.SystemException {
2480                    return getPersistence()
2481                                       .findByC_ST(companyId, status, start, end, orderByComparator);
2482            }
2483    
2484            /**
2485            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
2486            *
2487            * <p>
2488            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2489            * </p>
2490            *
2491            * @param companyId the company ID
2492            * @param status the status
2493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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 findByC_ST_First(
2499                    long companyId, 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                                       .findByC_ST_First(companyId, status, orderByComparator);
2505            }
2506    
2507            /**
2508            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
2509            *
2510            * <p>
2511            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2512            * </p>
2513            *
2514            * @param companyId the company ID
2515            * @param status the status
2516            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2517            * @return the last matching journal article
2518            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2519            * @throws SystemException if a system exception occurred
2520            */
2521            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
2522                    long companyId, int status,
2523                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2524                    throws com.liferay.portal.kernel.exception.SystemException,
2525                            com.liferay.portlet.journal.NoSuchArticleException {
2526                    return getPersistence()
2527                                       .findByC_ST_Last(companyId, status, orderByComparator);
2528            }
2529    
2530            /**
2531            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
2532            *
2533            * <p>
2534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2535            * </p>
2536            *
2537            * @param id the primary key of the current journal article
2538            * @param companyId the company ID
2539            * @param status the status
2540            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2541            * @return the previous, current, and next journal article
2542            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2543            * @throws SystemException if a system exception occurred
2544            */
2545            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
2546                    long id, long companyId, int status,
2547                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2548                    throws com.liferay.portal.kernel.exception.SystemException,
2549                            com.liferay.portlet.journal.NoSuchArticleException {
2550                    return getPersistence()
2551                                       .findByC_ST_PrevAndNext(id, companyId, status,
2552                            orderByComparator);
2553            }
2554    
2555            /**
2556            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2557            *
2558            * @param groupId the group ID
2559            * @param classNameId the class name ID
2560            * @param classPK the class p k
2561            * @return the matching journal articles
2562            * @throws SystemException if a system exception occurred
2563            */
2564            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2565                    long groupId, long classNameId, long classPK)
2566                    throws com.liferay.portal.kernel.exception.SystemException {
2567                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
2568            }
2569    
2570            /**
2571            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2572            *
2573            * <p>
2574            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2575            * </p>
2576            *
2577            * @param groupId the group ID
2578            * @param classNameId the class name ID
2579            * @param classPK the class p k
2580            * @param start the lower bound of the range of journal articles
2581            * @param end the upper bound of the range of journal articles (not inclusive)
2582            * @return the range of matching journal articles
2583            * @throws SystemException if a system exception occurred
2584            */
2585            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2586                    long groupId, long classNameId, long classPK, int start, int end)
2587                    throws com.liferay.portal.kernel.exception.SystemException {
2588                    return getPersistence()
2589                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
2590            }
2591    
2592            /**
2593            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2594            *
2595            * <p>
2596            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2597            * </p>
2598            *
2599            * @param groupId the group ID
2600            * @param classNameId the class name ID
2601            * @param classPK the class p k
2602            * @param start the lower bound of the range of journal articles
2603            * @param end the upper bound of the range of journal articles (not inclusive)
2604            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2605            * @return the ordered range of matching journal articles
2606            * @throws SystemException if a system exception occurred
2607            */
2608            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2609                    long groupId, long classNameId, long classPK, int start, int end,
2610                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2611                    throws com.liferay.portal.kernel.exception.SystemException {
2612                    return getPersistence()
2613                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
2614                            orderByComparator);
2615            }
2616    
2617            /**
2618            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2619            *
2620            * <p>
2621            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2622            * </p>
2623            *
2624            * @param groupId the group ID
2625            * @param classNameId the class name ID
2626            * @param classPK the class p k
2627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2628            * @return the first matching journal article
2629            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2630            * @throws SystemException if a system exception occurred
2631            */
2632            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
2633                    long groupId, long classNameId, long classPK,
2634                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2635                    throws com.liferay.portal.kernel.exception.SystemException,
2636                            com.liferay.portlet.journal.NoSuchArticleException {
2637                    return getPersistence()
2638                                       .findByG_C_C_First(groupId, classNameId, classPK,
2639                            orderByComparator);
2640            }
2641    
2642            /**
2643            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2644            *
2645            * <p>
2646            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2647            * </p>
2648            *
2649            * @param groupId the group ID
2650            * @param classNameId the class name ID
2651            * @param classPK the class p k
2652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2653            * @return the last matching journal article
2654            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2655            * @throws SystemException if a system exception occurred
2656            */
2657            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
2658                    long groupId, long classNameId, long classPK,
2659                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2660                    throws com.liferay.portal.kernel.exception.SystemException,
2661                            com.liferay.portlet.journal.NoSuchArticleException {
2662                    return getPersistence()
2663                                       .findByG_C_C_Last(groupId, classNameId, classPK,
2664                            orderByComparator);
2665            }
2666    
2667            /**
2668            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2669            *
2670            * <p>
2671            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2672            * </p>
2673            *
2674            * @param id the primary key of the current journal article
2675            * @param groupId the group ID
2676            * @param classNameId the class name ID
2677            * @param classPK the class p k
2678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2679            * @return the previous, current, and next journal article
2680            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2681            * @throws SystemException if a system exception occurred
2682            */
2683            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
2684                    long id, long groupId, long classNameId, long classPK,
2685                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2686                    throws com.liferay.portal.kernel.exception.SystemException,
2687                            com.liferay.portlet.journal.NoSuchArticleException {
2688                    return getPersistence()
2689                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
2690                            orderByComparator);
2691            }
2692    
2693            /**
2694            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2695            *
2696            * @param groupId the group ID
2697            * @param classNameId the class name ID
2698            * @param classPK the class p k
2699            * @return the matching journal articles that the user has permission to view
2700            * @throws SystemException if a system exception occurred
2701            */
2702            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2703                    long groupId, long classNameId, long classPK)
2704                    throws com.liferay.portal.kernel.exception.SystemException {
2705                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
2706            }
2707    
2708            /**
2709            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2710            *
2711            * <p>
2712            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2713            * </p>
2714            *
2715            * @param groupId the group ID
2716            * @param classNameId the class name ID
2717            * @param classPK the class p k
2718            * @param start the lower bound of the range of journal articles
2719            * @param end the upper bound of the range of journal articles (not inclusive)
2720            * @return the range of matching journal articles that the user has permission to view
2721            * @throws SystemException if a system exception occurred
2722            */
2723            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2724                    long groupId, long classNameId, long classPK, int start, int end)
2725                    throws com.liferay.portal.kernel.exception.SystemException {
2726                    return getPersistence()
2727                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
2728            }
2729    
2730            /**
2731            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2732            *
2733            * <p>
2734            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2735            * </p>
2736            *
2737            * @param groupId the group ID
2738            * @param classNameId the class name ID
2739            * @param classPK the class p k
2740            * @param start the lower bound of the range of journal articles
2741            * @param end the upper bound of the range of journal articles (not inclusive)
2742            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2743            * @return the ordered range of matching journal articles that the user has permission to view
2744            * @throws SystemException if a system exception occurred
2745            */
2746            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2747                    long groupId, long classNameId, long classPK, int start, int end,
2748                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2749                    throws com.liferay.portal.kernel.exception.SystemException {
2750                    return getPersistence()
2751                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
2752                            end, orderByComparator);
2753            }
2754    
2755            /**
2756            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2757            *
2758            * @param id the primary key of the current journal article
2759            * @param groupId the group ID
2760            * @param classNameId the class name ID
2761            * @param classPK the class p k
2762            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2763            * @return the previous, current, and next journal article
2764            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2765            * @throws SystemException if a system exception occurred
2766            */
2767            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
2768                    long id, long groupId, long classNameId, long classPK,
2769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2770                    throws com.liferay.portal.kernel.exception.SystemException,
2771                            com.liferay.portlet.journal.NoSuchArticleException {
2772                    return getPersistence()
2773                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
2774                            classPK, orderByComparator);
2775            }
2776    
2777            /**
2778            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
2779            *
2780            * @param groupId the group ID
2781            * @param classNameId the class name ID
2782            * @param structureId the structure ID
2783            * @return the matching journal article
2784            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2785            * @throws SystemException if a system exception occurred
2786            */
2787            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
2788                    long groupId, long classNameId, java.lang.String structureId)
2789                    throws com.liferay.portal.kernel.exception.SystemException,
2790                            com.liferay.portlet.journal.NoSuchArticleException {
2791                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
2792            }
2793    
2794            /**
2795            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2796            *
2797            * @param groupId the group ID
2798            * @param classNameId the class name ID
2799            * @param structureId the structure ID
2800            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
2801            * @throws SystemException if a system exception occurred
2802            */
2803            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
2804                    long groupId, long classNameId, java.lang.String structureId)
2805                    throws com.liferay.portal.kernel.exception.SystemException {
2806                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
2807            }
2808    
2809            /**
2810            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2811            *
2812            * @param groupId the group ID
2813            * @param classNameId the class name ID
2814            * @param structureId the structure ID
2815            * @param retrieveFromCache whether to use the finder cache
2816            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
2817            * @throws SystemException if a system exception occurred
2818            */
2819            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
2820                    long groupId, long classNameId, java.lang.String structureId,
2821                    boolean retrieveFromCache)
2822                    throws com.liferay.portal.kernel.exception.SystemException {
2823                    return getPersistence()
2824                                       .fetchByG_C_S(groupId, classNameId, structureId,
2825                            retrieveFromCache);
2826            }
2827    
2828            /**
2829            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2830            *
2831            * @param groupId the group ID
2832            * @param classNameId the class name ID
2833            * @param templateId the template ID
2834            * @return the matching journal articles
2835            * @throws SystemException if a system exception occurred
2836            */
2837            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
2838                    long groupId, long classNameId, java.lang.String templateId)
2839                    throws com.liferay.portal.kernel.exception.SystemException {
2840                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
2841            }
2842    
2843            /**
2844            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2845            *
2846            * <p>
2847            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2848            * </p>
2849            *
2850            * @param groupId the group ID
2851            * @param classNameId the class name ID
2852            * @param templateId the template ID
2853            * @param start the lower bound of the range of journal articles
2854            * @param end the upper bound of the range of journal articles (not inclusive)
2855            * @return the range of matching journal articles
2856            * @throws SystemException if a system exception occurred
2857            */
2858            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
2859                    long groupId, long classNameId, java.lang.String templateId, int start,
2860                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2861                    return getPersistence()
2862                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
2863            }
2864    
2865            /**
2866            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2867            *
2868            * <p>
2869            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2870            * </p>
2871            *
2872            * @param groupId the group ID
2873            * @param classNameId the class name ID
2874            * @param templateId the template ID
2875            * @param start the lower bound of the range of journal articles
2876            * @param end the upper bound of the range of journal articles (not inclusive)
2877            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2878            * @return the ordered range of matching journal articles
2879            * @throws SystemException if a system exception occurred
2880            */
2881            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
2882                    long groupId, long classNameId, java.lang.String templateId, int start,
2883                    int end,
2884                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2885                    throws com.liferay.portal.kernel.exception.SystemException {
2886                    return getPersistence()
2887                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
2888                            orderByComparator);
2889            }
2890    
2891            /**
2892            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#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 groupId the group ID
2899            * @param classNameId the class name ID
2900            * @param templateId the template ID
2901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2902            * @return the first matching journal article
2903            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2904            * @throws SystemException if a system exception occurred
2905            */
2906            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
2907                    long groupId, long classNameId, java.lang.String templateId,
2908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2909                    throws com.liferay.portal.kernel.exception.SystemException,
2910                            com.liferay.portlet.journal.NoSuchArticleException {
2911                    return getPersistence()
2912                                       .findByG_C_T_First(groupId, classNameId, templateId,
2913                            orderByComparator);
2914            }
2915    
2916            /**
2917            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2918            *
2919            * <p>
2920            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2921            * </p>
2922            *
2923            * @param groupId the group ID
2924            * @param classNameId the class name ID
2925            * @param templateId the template ID
2926            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2927            * @return the last matching journal article
2928            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2929            * @throws SystemException if a system exception occurred
2930            */
2931            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
2932                    long groupId, long classNameId, java.lang.String templateId,
2933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2934                    throws com.liferay.portal.kernel.exception.SystemException,
2935                            com.liferay.portlet.journal.NoSuchArticleException {
2936                    return getPersistence()
2937                                       .findByG_C_T_Last(groupId, classNameId, templateId,
2938                            orderByComparator);
2939            }
2940    
2941            /**
2942            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2943            *
2944            * <p>
2945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2946            * </p>
2947            *
2948            * @param id the primary key of the current journal article
2949            * @param groupId the group ID
2950            * @param classNameId the class name ID
2951            * @param templateId the template ID
2952            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2953            * @return the previous, current, and next journal article
2954            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2955            * @throws SystemException if a system exception occurred
2956            */
2957            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
2958                    long id, long groupId, long classNameId, java.lang.String templateId,
2959                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2960                    throws com.liferay.portal.kernel.exception.SystemException,
2961                            com.liferay.portlet.journal.NoSuchArticleException {
2962                    return getPersistence()
2963                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
2964                            templateId, orderByComparator);
2965            }
2966    
2967            /**
2968            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2969            *
2970            * @param groupId the group ID
2971            * @param classNameId the class name ID
2972            * @param templateId the template ID
2973            * @return the matching journal articles that the user has permission to view
2974            * @throws SystemException if a system exception occurred
2975            */
2976            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
2977                    long groupId, long classNameId, java.lang.String templateId)
2978                    throws com.liferay.portal.kernel.exception.SystemException {
2979                    return getPersistence()
2980                                       .filterFindByG_C_T(groupId, classNameId, templateId);
2981            }
2982    
2983            /**
2984            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2985            *
2986            * <p>
2987            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2988            * </p>
2989            *
2990            * @param groupId the group ID
2991            * @param classNameId the class name ID
2992            * @param templateId the template ID
2993            * @param start the lower bound of the range of journal articles
2994            * @param end the upper bound of the range of journal articles (not inclusive)
2995            * @return the range of matching journal articles that the user has permission to view
2996            * @throws SystemException if a system exception occurred
2997            */
2998            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
2999                    long groupId, long classNameId, java.lang.String templateId, int start,
3000                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3001                    return getPersistence()
3002                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3003                            end);
3004            }
3005    
3006            /**
3007            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3008            *
3009            * <p>
3010            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3011            * </p>
3012            *
3013            * @param groupId the group ID
3014            * @param classNameId the class name ID
3015            * @param templateId the template ID
3016            * @param start the lower bound of the range of journal articles
3017            * @param end the upper bound of the range of journal articles (not inclusive)
3018            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3019            * @return the ordered range of matching journal articles that the user has permission to view
3020            * @throws SystemException if a system exception occurred
3021            */
3022            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3023                    long groupId, long classNameId, java.lang.String templateId, int start,
3024                    int end,
3025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3026                    throws com.liferay.portal.kernel.exception.SystemException {
3027                    return getPersistence()
3028                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3029                            end, orderByComparator);
3030            }
3031    
3032            /**
3033            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3034            *
3035            * @param id the primary key of the current journal article
3036            * @param groupId the group ID
3037            * @param classNameId the class name ID
3038            * @param templateId the template ID
3039            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3040            * @return the previous, current, and next journal article
3041            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3042            * @throws SystemException if a system exception occurred
3043            */
3044            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
3045                    long id, long groupId, long classNameId, java.lang.String templateId,
3046                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3047                    throws com.liferay.portal.kernel.exception.SystemException,
3048                            com.liferay.portlet.journal.NoSuchArticleException {
3049                    return getPersistence()
3050                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
3051                            templateId, orderByComparator);
3052            }
3053    
3054            /**
3055            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3056            *
3057            * @param groupId the group ID
3058            * @param classNameId the class name ID
3059            * @param layoutUuid the layout uuid
3060            * @return the matching journal articles
3061            * @throws SystemException if a system exception occurred
3062            */
3063            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3064                    long groupId, long classNameId, java.lang.String layoutUuid)
3065                    throws com.liferay.portal.kernel.exception.SystemException {
3066                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
3067            }
3068    
3069            /**
3070            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3071            *
3072            * <p>
3073            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3074            * </p>
3075            *
3076            * @param groupId the group ID
3077            * @param classNameId the class name ID
3078            * @param layoutUuid the layout uuid
3079            * @param start the lower bound of the range of journal articles
3080            * @param end the upper bound of the range of journal articles (not inclusive)
3081            * @return the range of matching journal articles
3082            * @throws SystemException if a system exception occurred
3083            */
3084            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3085                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3086                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3087                    return getPersistence()
3088                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
3089            }
3090    
3091            /**
3092            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3093            *
3094            * <p>
3095            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3096            * </p>
3097            *
3098            * @param groupId the group ID
3099            * @param classNameId the class name ID
3100            * @param layoutUuid the layout uuid
3101            * @param start the lower bound of the range of journal articles
3102            * @param end the upper bound of the range of journal articles (not inclusive)
3103            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3104            * @return the ordered range of matching journal articles
3105            * @throws SystemException if a system exception occurred
3106            */
3107            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3108                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3109                    int end,
3110                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3111                    throws com.liferay.portal.kernel.exception.SystemException {
3112                    return getPersistence()
3113                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
3114                            orderByComparator);
3115            }
3116    
3117            /**
3118            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3119            *
3120            * <p>
3121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3122            * </p>
3123            *
3124            * @param groupId the group ID
3125            * @param classNameId the class name ID
3126            * @param layoutUuid the layout uuid
3127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3128            * @return the first matching journal article
3129            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3130            * @throws SystemException if a system exception occurred
3131            */
3132            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
3133                    long groupId, long classNameId, java.lang.String layoutUuid,
3134                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3135                    throws com.liferay.portal.kernel.exception.SystemException,
3136                            com.liferay.portlet.journal.NoSuchArticleException {
3137                    return getPersistence()
3138                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
3139                            orderByComparator);
3140            }
3141    
3142            /**
3143            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3144            *
3145            * <p>
3146            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3147            * </p>
3148            *
3149            * @param groupId the group ID
3150            * @param classNameId the class name ID
3151            * @param layoutUuid the layout uuid
3152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3153            * @return the last matching journal article
3154            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3155            * @throws SystemException if a system exception occurred
3156            */
3157            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
3158                    long groupId, long classNameId, java.lang.String layoutUuid,
3159                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3160                    throws com.liferay.portal.kernel.exception.SystemException,
3161                            com.liferay.portlet.journal.NoSuchArticleException {
3162                    return getPersistence()
3163                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
3164                            orderByComparator);
3165            }
3166    
3167            /**
3168            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3169            *
3170            * <p>
3171            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3172            * </p>
3173            *
3174            * @param id the primary key of the current journal article
3175            * @param groupId the group ID
3176            * @param classNameId the class name ID
3177            * @param layoutUuid the layout uuid
3178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3179            * @return the previous, current, and next journal article
3180            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3181            * @throws SystemException if a system exception occurred
3182            */
3183            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
3184                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3185                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3186                    throws com.liferay.portal.kernel.exception.SystemException,
3187                            com.liferay.portlet.journal.NoSuchArticleException {
3188                    return getPersistence()
3189                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
3190                            layoutUuid, orderByComparator);
3191            }
3192    
3193            /**
3194            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3195            *
3196            * @param groupId the group ID
3197            * @param classNameId the class name ID
3198            * @param layoutUuid the layout uuid
3199            * @return the matching journal articles that the user has permission to view
3200            * @throws SystemException if a system exception occurred
3201            */
3202            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3203                    long groupId, long classNameId, java.lang.String layoutUuid)
3204                    throws com.liferay.portal.kernel.exception.SystemException {
3205                    return getPersistence()
3206                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
3207            }
3208    
3209            /**
3210            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3211            *
3212            * <p>
3213            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3214            * </p>
3215            *
3216            * @param groupId the group ID
3217            * @param classNameId the class name ID
3218            * @param layoutUuid the layout uuid
3219            * @param start the lower bound of the range of journal articles
3220            * @param end the upper bound of the range of journal articles (not inclusive)
3221            * @return the range of matching journal articles that the user has permission to view
3222            * @throws SystemException if a system exception occurred
3223            */
3224            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3225                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3226                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3227                    return getPersistence()
3228                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3229                            end);
3230            }
3231    
3232            /**
3233            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3234            *
3235            * <p>
3236            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3237            * </p>
3238            *
3239            * @param groupId the group ID
3240            * @param classNameId the class name ID
3241            * @param layoutUuid the layout uuid
3242            * @param start the lower bound of the range of journal articles
3243            * @param end the upper bound of the range of journal articles (not inclusive)
3244            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3245            * @return the ordered range of matching journal articles that the user has permission to view
3246            * @throws SystemException if a system exception occurred
3247            */
3248            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3249                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3250                    int end,
3251                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3252                    throws com.liferay.portal.kernel.exception.SystemException {
3253                    return getPersistence()
3254                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3255                            end, orderByComparator);
3256            }
3257    
3258            /**
3259            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3260            *
3261            * @param id the primary key of the current journal article
3262            * @param groupId the group ID
3263            * @param classNameId the class name ID
3264            * @param layoutUuid the layout uuid
3265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3266            * @return the previous, current, and next journal article
3267            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3268            * @throws SystemException if a system exception occurred
3269            */
3270            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
3271                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3273                    throws com.liferay.portal.kernel.exception.SystemException,
3274                            com.liferay.portlet.journal.NoSuchArticleException {
3275                    return getPersistence()
3276                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
3277                            layoutUuid, orderByComparator);
3278            }
3279    
3280            /**
3281            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
3282            *
3283            * @param groupId the group ID
3284            * @param articleId the article ID
3285            * @param version the version
3286            * @return the matching journal article
3287            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3288            * @throws SystemException if a system exception occurred
3289            */
3290            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
3291                    long groupId, java.lang.String articleId, double version)
3292                    throws com.liferay.portal.kernel.exception.SystemException,
3293                            com.liferay.portlet.journal.NoSuchArticleException {
3294                    return getPersistence().findByG_A_V(groupId, articleId, version);
3295            }
3296    
3297            /**
3298            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
3299            *
3300            * @param groupId the group ID
3301            * @param articleId the article ID
3302            * @param version the version
3303            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3304            * @throws SystemException if a system exception occurred
3305            */
3306            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3307                    long groupId, java.lang.String articleId, double version)
3308                    throws com.liferay.portal.kernel.exception.SystemException {
3309                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
3310            }
3311    
3312            /**
3313            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
3314            *
3315            * @param groupId the group ID
3316            * @param articleId the article ID
3317            * @param version the version
3318            * @param retrieveFromCache whether to use the finder cache
3319            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3320            * @throws SystemException if a system exception occurred
3321            */
3322            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3323                    long groupId, java.lang.String articleId, double version,
3324                    boolean retrieveFromCache)
3325                    throws com.liferay.portal.kernel.exception.SystemException {
3326                    return getPersistence()
3327                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
3328            }
3329    
3330            /**
3331            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3332            *
3333            * @param groupId the group ID
3334            * @param articleId the article ID
3335            * @param status the status
3336            * @return the matching journal articles
3337            * @throws SystemException if a system exception occurred
3338            */
3339            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3340                    long groupId, java.lang.String articleId, int status)
3341                    throws com.liferay.portal.kernel.exception.SystemException {
3342                    return getPersistence().findByG_A_ST(groupId, articleId, status);
3343            }
3344    
3345            /**
3346            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3347            *
3348            * <p>
3349            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3350            * </p>
3351            *
3352            * @param groupId the group ID
3353            * @param articleId the article ID
3354            * @param status the status
3355            * @param start the lower bound of the range of journal articles
3356            * @param end the upper bound of the range of journal articles (not inclusive)
3357            * @return the range of matching journal articles
3358            * @throws SystemException if a system exception occurred
3359            */
3360            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3361                    long groupId, java.lang.String articleId, int status, int start, int end)
3362                    throws com.liferay.portal.kernel.exception.SystemException {
3363                    return getPersistence()
3364                                       .findByG_A_ST(groupId, articleId, status, start, end);
3365            }
3366    
3367            /**
3368            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3369            *
3370            * <p>
3371            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3372            * </p>
3373            *
3374            * @param groupId the group ID
3375            * @param articleId the article ID
3376            * @param status the status
3377            * @param start the lower bound of the range of journal articles
3378            * @param end the upper bound of the range of journal articles (not inclusive)
3379            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3380            * @return the ordered range of matching journal articles
3381            * @throws SystemException if a system exception occurred
3382            */
3383            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3384                    long groupId, java.lang.String articleId, int status, int start,
3385                    int end,
3386                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3387                    throws com.liferay.portal.kernel.exception.SystemException {
3388                    return getPersistence()
3389                                       .findByG_A_ST(groupId, articleId, status, start, end,
3390                            orderByComparator);
3391            }
3392    
3393            /**
3394            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3395            *
3396            * <p>
3397            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3398            * </p>
3399            *
3400            * @param groupId the group ID
3401            * @param articleId the article ID
3402            * @param status the status
3403            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3404            * @return the first matching journal article
3405            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3406            * @throws SystemException if a system exception occurred
3407            */
3408            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
3409                    long groupId, java.lang.String articleId, int status,
3410                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3411                    throws com.liferay.portal.kernel.exception.SystemException,
3412                            com.liferay.portlet.journal.NoSuchArticleException {
3413                    return getPersistence()
3414                                       .findByG_A_ST_First(groupId, articleId, status,
3415                            orderByComparator);
3416            }
3417    
3418            /**
3419            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3420            *
3421            * <p>
3422            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3423            * </p>
3424            *
3425            * @param groupId the group ID
3426            * @param articleId the article ID
3427            * @param status the status
3428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3429            * @return the last matching journal article
3430            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3431            * @throws SystemException if a system exception occurred
3432            */
3433            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
3434                    long groupId, java.lang.String articleId, int status,
3435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3436                    throws com.liferay.portal.kernel.exception.SystemException,
3437                            com.liferay.portlet.journal.NoSuchArticleException {
3438                    return getPersistence()
3439                                       .findByG_A_ST_Last(groupId, articleId, status,
3440                            orderByComparator);
3441            }
3442    
3443            /**
3444            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3445            *
3446            * <p>
3447            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3448            * </p>
3449            *
3450            * @param id the primary key of the current journal article
3451            * @param groupId the group ID
3452            * @param articleId the article ID
3453            * @param status the status
3454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3455            * @return the previous, current, and next journal article
3456            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3457            * @throws SystemException if a system exception occurred
3458            */
3459            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
3460                    long id, long groupId, java.lang.String articleId, int status,
3461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3462                    throws com.liferay.portal.kernel.exception.SystemException,
3463                            com.liferay.portlet.journal.NoSuchArticleException {
3464                    return getPersistence()
3465                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
3466                            orderByComparator);
3467            }
3468    
3469            /**
3470            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3471            *
3472            * @param groupId the group ID
3473            * @param articleId the article ID
3474            * @param status the status
3475            * @return the matching journal articles that the user has permission to view
3476            * @throws SystemException if a system exception occurred
3477            */
3478            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3479                    long groupId, java.lang.String articleId, int status)
3480                    throws com.liferay.portal.kernel.exception.SystemException {
3481                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
3482            }
3483    
3484            /**
3485            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3486            *
3487            * <p>
3488            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3489            * </p>
3490            *
3491            * @param groupId the group ID
3492            * @param articleId the article ID
3493            * @param status the status
3494            * @param start the lower bound of the range of journal articles
3495            * @param end the upper bound of the range of journal articles (not inclusive)
3496            * @return the range of matching journal articles that the user has permission to view
3497            * @throws SystemException if a system exception occurred
3498            */
3499            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3500                    long groupId, java.lang.String articleId, int status, int start, int end)
3501                    throws com.liferay.portal.kernel.exception.SystemException {
3502                    return getPersistence()
3503                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
3504            }
3505    
3506            /**
3507            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3508            *
3509            * <p>
3510            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3511            * </p>
3512            *
3513            * @param groupId the group ID
3514            * @param articleId the article ID
3515            * @param status the status
3516            * @param start the lower bound of the range of journal articles
3517            * @param end the upper bound of the range of journal articles (not inclusive)
3518            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3519            * @return the ordered range of matching journal articles that the user has permission to view
3520            * @throws SystemException if a system exception occurred
3521            */
3522            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3523                    long groupId, java.lang.String articleId, int status, int start,
3524                    int end,
3525                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3526                    throws com.liferay.portal.kernel.exception.SystemException {
3527                    return getPersistence()
3528                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
3529                            orderByComparator);
3530            }
3531    
3532            /**
3533            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3534            *
3535            * @param id the primary key of the current journal article
3536            * @param groupId the group ID
3537            * @param articleId the article ID
3538            * @param status the status
3539            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3540            * @return the previous, current, and next journal article
3541            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3542            * @throws SystemException if a system exception occurred
3543            */
3544            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
3545                    long id, long groupId, java.lang.String articleId, int status,
3546                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3547                    throws com.liferay.portal.kernel.exception.SystemException,
3548                            com.liferay.portlet.journal.NoSuchArticleException {
3549                    return getPersistence()
3550                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
3551                            status, orderByComparator);
3552            }
3553    
3554            /**
3555            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3556            *
3557            * @param groupId the group ID
3558            * @param urlTitle the url title
3559            * @param status the status
3560            * @return the matching journal articles
3561            * @throws SystemException if a system exception occurred
3562            */
3563            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3564                    long groupId, java.lang.String urlTitle, int status)
3565                    throws com.liferay.portal.kernel.exception.SystemException {
3566                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
3567            }
3568    
3569            /**
3570            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3571            *
3572            * <p>
3573            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3574            * </p>
3575            *
3576            * @param groupId the group ID
3577            * @param urlTitle the url title
3578            * @param status the status
3579            * @param start the lower bound of the range of journal articles
3580            * @param end the upper bound of the range of journal articles (not inclusive)
3581            * @return the range of matching journal articles
3582            * @throws SystemException if a system exception occurred
3583            */
3584            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3585                    long groupId, java.lang.String urlTitle, int status, int start, int end)
3586                    throws com.liferay.portal.kernel.exception.SystemException {
3587                    return getPersistence()
3588                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
3589            }
3590    
3591            /**
3592            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3593            *
3594            * <p>
3595            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3596            * </p>
3597            *
3598            * @param groupId the group ID
3599            * @param urlTitle the url title
3600            * @param status the status
3601            * @param start the lower bound of the range of journal articles
3602            * @param end the upper bound of the range of journal articles (not inclusive)
3603            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3604            * @return the ordered range of matching journal articles
3605            * @throws SystemException if a system exception occurred
3606            */
3607            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3608                    long groupId, java.lang.String urlTitle, int status, int start,
3609                    int end,
3610                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3611                    throws com.liferay.portal.kernel.exception.SystemException {
3612                    return getPersistence()
3613                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
3614                            orderByComparator);
3615            }
3616    
3617            /**
3618            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3619            *
3620            * <p>
3621            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3622            * </p>
3623            *
3624            * @param groupId the group ID
3625            * @param urlTitle the url title
3626            * @param status the status
3627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3628            * @return the first matching journal article
3629            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3630            * @throws SystemException if a system exception occurred
3631            */
3632            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
3633                    long groupId, java.lang.String urlTitle, int status,
3634                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3635                    throws com.liferay.portal.kernel.exception.SystemException,
3636                            com.liferay.portlet.journal.NoSuchArticleException {
3637                    return getPersistence()
3638                                       .findByG_UT_ST_First(groupId, urlTitle, status,
3639                            orderByComparator);
3640            }
3641    
3642            /**
3643            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3644            *
3645            * <p>
3646            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3647            * </p>
3648            *
3649            * @param groupId the group ID
3650            * @param urlTitle the url title
3651            * @param status the status
3652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3653            * @return the last matching journal article
3654            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3655            * @throws SystemException if a system exception occurred
3656            */
3657            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
3658                    long groupId, java.lang.String urlTitle, int status,
3659                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3660                    throws com.liferay.portal.kernel.exception.SystemException,
3661                            com.liferay.portlet.journal.NoSuchArticleException {
3662                    return getPersistence()
3663                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
3664                            orderByComparator);
3665            }
3666    
3667            /**
3668            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3669            *
3670            * <p>
3671            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3672            * </p>
3673            *
3674            * @param id the primary key of the current journal article
3675            * @param groupId the group ID
3676            * @param urlTitle the url title
3677            * @param status the status
3678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3679            * @return the previous, current, and next journal article
3680            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3681            * @throws SystemException if a system exception occurred
3682            */
3683            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
3684                    long id, long groupId, java.lang.String urlTitle, int status,
3685                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3686                    throws com.liferay.portal.kernel.exception.SystemException,
3687                            com.liferay.portlet.journal.NoSuchArticleException {
3688                    return getPersistence()
3689                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
3690                            orderByComparator);
3691            }
3692    
3693            /**
3694            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3695            *
3696            * @param groupId the group ID
3697            * @param urlTitle the url title
3698            * @param status the status
3699            * @return the matching journal articles that the user has permission to view
3700            * @throws SystemException if a system exception occurred
3701            */
3702            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
3703                    long groupId, java.lang.String urlTitle, int status)
3704                    throws com.liferay.portal.kernel.exception.SystemException {
3705                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
3706            }
3707    
3708            /**
3709            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3710            *
3711            * <p>
3712            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3713            * </p>
3714            *
3715            * @param groupId the group ID
3716            * @param urlTitle the url title
3717            * @param status the status
3718            * @param start the lower bound of the range of journal articles
3719            * @param end the upper bound of the range of journal articles (not inclusive)
3720            * @return the range of matching journal articles that the user has permission to view
3721            * @throws SystemException if a system exception occurred
3722            */
3723            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
3724                    long groupId, java.lang.String urlTitle, int status, int start, int end)
3725                    throws com.liferay.portal.kernel.exception.SystemException {
3726                    return getPersistence()
3727                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
3728            }
3729    
3730            /**
3731            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3732            *
3733            * <p>
3734            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3735            * </p>
3736            *
3737            * @param groupId the group ID
3738            * @param urlTitle the url title
3739            * @param status the status
3740            * @param start the lower bound of the range of journal articles
3741            * @param end the upper bound of the range of journal articles (not inclusive)
3742            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3743            * @return the ordered range of matching journal articles that the user has permission to view
3744            * @throws SystemException if a system exception occurred
3745            */
3746            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
3747                    long groupId, java.lang.String urlTitle, int status, int start,
3748                    int end,
3749                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3750                    throws com.liferay.portal.kernel.exception.SystemException {
3751                    return getPersistence()
3752                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
3753                            orderByComparator);
3754            }
3755    
3756            /**
3757            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3758            *
3759            * @param id the primary key of the current journal article
3760            * @param groupId the group ID
3761            * @param urlTitle the url title
3762            * @param status the status
3763            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3764            * @return the previous, current, and next journal article
3765            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3766            * @throws SystemException if a system exception occurred
3767            */
3768            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
3769                    long id, long groupId, java.lang.String urlTitle, int status,
3770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3771                    throws com.liferay.portal.kernel.exception.SystemException,
3772                            com.liferay.portlet.journal.NoSuchArticleException {
3773                    return getPersistence()
3774                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
3775                            status, orderByComparator);
3776            }
3777    
3778            /**
3779            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
3780            *
3781            * @param companyId the company ID
3782            * @param version the version
3783            * @param status the status
3784            * @return the matching journal articles
3785            * @throws SystemException if a system exception occurred
3786            */
3787            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
3788                    long companyId, double version, int status)
3789                    throws com.liferay.portal.kernel.exception.SystemException {
3790                    return getPersistence().findByC_V_ST(companyId, version, status);
3791            }
3792    
3793            /**
3794            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
3795            *
3796            * <p>
3797            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3798            * </p>
3799            *
3800            * @param companyId the company ID
3801            * @param version the version
3802            * @param status the status
3803            * @param start the lower bound of the range of journal articles
3804            * @param end the upper bound of the range of journal articles (not inclusive)
3805            * @return the range of matching journal articles
3806            * @throws SystemException if a system exception occurred
3807            */
3808            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
3809                    long companyId, double version, int status, int start, int end)
3810                    throws com.liferay.portal.kernel.exception.SystemException {
3811                    return getPersistence()
3812                                       .findByC_V_ST(companyId, version, status, start, end);
3813            }
3814    
3815            /**
3816            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
3817            *
3818            * <p>
3819            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3820            * </p>
3821            *
3822            * @param companyId the company ID
3823            * @param version the version
3824            * @param status the status
3825            * @param start the lower bound of the range of journal articles
3826            * @param end the upper bound of the range of journal articles (not inclusive)
3827            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3828            * @return the ordered range of matching journal articles
3829            * @throws SystemException if a system exception occurred
3830            */
3831            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
3832                    long companyId, double version, int status, int start, int end,
3833                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3834                    throws com.liferay.portal.kernel.exception.SystemException {
3835                    return getPersistence()
3836                                       .findByC_V_ST(companyId, version, status, start, end,
3837                            orderByComparator);
3838            }
3839    
3840            /**
3841            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
3842            *
3843            * <p>
3844            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3845            * </p>
3846            *
3847            * @param companyId the company ID
3848            * @param version the version
3849            * @param status the status
3850            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3851            * @return the first matching journal article
3852            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3853            * @throws SystemException if a system exception occurred
3854            */
3855            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
3856                    long companyId, double version, int status,
3857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3858                    throws com.liferay.portal.kernel.exception.SystemException,
3859                            com.liferay.portlet.journal.NoSuchArticleException {
3860                    return getPersistence()
3861                                       .findByC_V_ST_First(companyId, version, status,
3862                            orderByComparator);
3863            }
3864    
3865            /**
3866            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
3867            *
3868            * <p>
3869            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3870            * </p>
3871            *
3872            * @param companyId the company ID
3873            * @param version the version
3874            * @param status the status
3875            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3876            * @return the last matching journal article
3877            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3878            * @throws SystemException if a system exception occurred
3879            */
3880            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
3881                    long companyId, double version, int status,
3882                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3883                    throws com.liferay.portal.kernel.exception.SystemException,
3884                            com.liferay.portlet.journal.NoSuchArticleException {
3885                    return getPersistence()
3886                                       .findByC_V_ST_Last(companyId, version, status,
3887                            orderByComparator);
3888            }
3889    
3890            /**
3891            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
3892            *
3893            * <p>
3894            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3895            * </p>
3896            *
3897            * @param id the primary key of the current journal article
3898            * @param companyId the company ID
3899            * @param version the version
3900            * @param status the status
3901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3902            * @return the previous, current, and next journal article
3903            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3904            * @throws SystemException if a system exception occurred
3905            */
3906            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
3907                    long id, long companyId, double version, int status,
3908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3909                    throws com.liferay.portal.kernel.exception.SystemException,
3910                            com.liferay.portlet.journal.NoSuchArticleException {
3911                    return getPersistence()
3912                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
3913                            orderByComparator);
3914            }
3915    
3916            /**
3917            * Returns all the journal articles.
3918            *
3919            * @return the journal articles
3920            * @throws SystemException if a system exception occurred
3921            */
3922            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
3923                    throws com.liferay.portal.kernel.exception.SystemException {
3924                    return getPersistence().findAll();
3925            }
3926    
3927            /**
3928            * Returns a range of all the journal articles.
3929            *
3930            * <p>
3931            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3932            * </p>
3933            *
3934            * @param start the lower bound of the range of journal articles
3935            * @param end the upper bound of the range of journal articles (not inclusive)
3936            * @return the range of journal articles
3937            * @throws SystemException if a system exception occurred
3938            */
3939            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
3940                    int start, int end)
3941                    throws com.liferay.portal.kernel.exception.SystemException {
3942                    return getPersistence().findAll(start, end);
3943            }
3944    
3945            /**
3946            * Returns an ordered range of all the journal articles.
3947            *
3948            * <p>
3949            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3950            * </p>
3951            *
3952            * @param start the lower bound of the range of journal articles
3953            * @param end the upper bound of the range of journal articles (not inclusive)
3954            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3955            * @return the ordered range of journal articles
3956            * @throws SystemException if a system exception occurred
3957            */
3958            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
3959                    int start, int end,
3960                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3961                    throws com.liferay.portal.kernel.exception.SystemException {
3962                    return getPersistence().findAll(start, end, orderByComparator);
3963            }
3964    
3965            /**
3966            * Removes all the journal articles where uuid = &#63; from the database.
3967            *
3968            * @param uuid the uuid
3969            * @throws SystemException if a system exception occurred
3970            */
3971            public static void removeByUuid(java.lang.String uuid)
3972                    throws com.liferay.portal.kernel.exception.SystemException {
3973                    getPersistence().removeByUuid(uuid);
3974            }
3975    
3976            /**
3977            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
3978            *
3979            * @param uuid the uuid
3980            * @param groupId the group ID
3981            * @throws SystemException if a system exception occurred
3982            */
3983            public static void removeByUUID_G(java.lang.String uuid, long groupId)
3984                    throws com.liferay.portal.kernel.exception.SystemException,
3985                            com.liferay.portlet.journal.NoSuchArticleException {
3986                    getPersistence().removeByUUID_G(uuid, groupId);
3987            }
3988    
3989            /**
3990            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
3991            *
3992            * @param resourcePrimKey the resource prim key
3993            * @throws SystemException if a system exception occurred
3994            */
3995            public static void removeByResourcePrimKey(long resourcePrimKey)
3996                    throws com.liferay.portal.kernel.exception.SystemException {
3997                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
3998            }
3999    
4000            /**
4001            * Removes all the journal articles where groupId = &#63; from the database.
4002            *
4003            * @param groupId the group ID
4004            * @throws SystemException if a system exception occurred
4005            */
4006            public static void removeByGroupId(long groupId)
4007                    throws com.liferay.portal.kernel.exception.SystemException {
4008                    getPersistence().removeByGroupId(groupId);
4009            }
4010    
4011            /**
4012            * Removes all the journal articles where companyId = &#63; from the database.
4013            *
4014            * @param companyId the company ID
4015            * @throws SystemException if a system exception occurred
4016            */
4017            public static void removeByCompanyId(long companyId)
4018                    throws com.liferay.portal.kernel.exception.SystemException {
4019                    getPersistence().removeByCompanyId(companyId);
4020            }
4021    
4022            /**
4023            * Removes all the journal articles where smallImageId = &#63; from the database.
4024            *
4025            * @param smallImageId the small image ID
4026            * @throws SystemException if a system exception occurred
4027            */
4028            public static void removeBySmallImageId(long smallImageId)
4029                    throws com.liferay.portal.kernel.exception.SystemException {
4030                    getPersistence().removeBySmallImageId(smallImageId);
4031            }
4032    
4033            /**
4034            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
4035            *
4036            * @param resourcePrimKey the resource prim key
4037            * @param status the status
4038            * @throws SystemException if a system exception occurred
4039            */
4040            public static void removeByR_ST(long resourcePrimKey, int status)
4041                    throws com.liferay.portal.kernel.exception.SystemException {
4042                    getPersistence().removeByR_ST(resourcePrimKey, status);
4043            }
4044    
4045            /**
4046            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
4047            *
4048            * @param groupId the group ID
4049            * @param articleId the article ID
4050            * @throws SystemException if a system exception occurred
4051            */
4052            public static void removeByG_A(long groupId, java.lang.String articleId)
4053                    throws com.liferay.portal.kernel.exception.SystemException {
4054                    getPersistence().removeByG_A(groupId, articleId);
4055            }
4056    
4057            /**
4058            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
4059            *
4060            * @param groupId the group ID
4061            * @param urlTitle the url title
4062            * @throws SystemException if a system exception occurred
4063            */
4064            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
4065                    throws com.liferay.portal.kernel.exception.SystemException {
4066                    getPersistence().removeByG_UT(groupId, urlTitle);
4067            }
4068    
4069            /**
4070            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
4071            *
4072            * @param groupId the group ID
4073            * @param structureId the structure ID
4074            * @throws SystemException if a system exception occurred
4075            */
4076            public static void removeByG_S(long groupId, java.lang.String structureId)
4077                    throws com.liferay.portal.kernel.exception.SystemException {
4078                    getPersistence().removeByG_S(groupId, structureId);
4079            }
4080    
4081            /**
4082            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
4083            *
4084            * @param groupId the group ID
4085            * @param templateId the template ID
4086            * @throws SystemException if a system exception occurred
4087            */
4088            public static void removeByG_T(long groupId, java.lang.String templateId)
4089                    throws com.liferay.portal.kernel.exception.SystemException {
4090                    getPersistence().removeByG_T(groupId, templateId);
4091            }
4092    
4093            /**
4094            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
4095            *
4096            * @param groupId the group ID
4097            * @param layoutUuid the layout uuid
4098            * @throws SystemException if a system exception occurred
4099            */
4100            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
4101                    throws com.liferay.portal.kernel.exception.SystemException {
4102                    getPersistence().removeByG_L(groupId, layoutUuid);
4103            }
4104    
4105            /**
4106            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4107            *
4108            * @param groupId the group ID
4109            * @param status the status
4110            * @throws SystemException if a system exception occurred
4111            */
4112            public static void removeByG_ST(long groupId, int status)
4113                    throws com.liferay.portal.kernel.exception.SystemException {
4114                    getPersistence().removeByG_ST(groupId, status);
4115            }
4116    
4117            /**
4118            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4119            *
4120            * @param companyId the company ID
4121            * @param version the version
4122            * @throws SystemException if a system exception occurred
4123            */
4124            public static void removeByC_V(long companyId, double version)
4125                    throws com.liferay.portal.kernel.exception.SystemException {
4126                    getPersistence().removeByC_V(companyId, version);
4127            }
4128    
4129            /**
4130            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4131            *
4132            * @param companyId the company ID
4133            * @param status the status
4134            * @throws SystemException if a system exception occurred
4135            */
4136            public static void removeByC_ST(long companyId, int status)
4137                    throws com.liferay.portal.kernel.exception.SystemException {
4138                    getPersistence().removeByC_ST(companyId, status);
4139            }
4140    
4141            /**
4142            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
4143            *
4144            * @param groupId the group ID
4145            * @param classNameId the class name ID
4146            * @param classPK the class p k
4147            * @throws SystemException if a system exception occurred
4148            */
4149            public static void removeByG_C_C(long groupId, long classNameId,
4150                    long classPK)
4151                    throws com.liferay.portal.kernel.exception.SystemException {
4152                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
4153            }
4154    
4155            /**
4156            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
4157            *
4158            * @param groupId the group ID
4159            * @param classNameId the class name ID
4160            * @param structureId the structure ID
4161            * @throws SystemException if a system exception occurred
4162            */
4163            public static void removeByG_C_S(long groupId, long classNameId,
4164                    java.lang.String structureId)
4165                    throws com.liferay.portal.kernel.exception.SystemException,
4166                            com.liferay.portlet.journal.NoSuchArticleException {
4167                    getPersistence().removeByG_C_S(groupId, classNameId, structureId);
4168            }
4169    
4170            /**
4171            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
4172            *
4173            * @param groupId the group ID
4174            * @param classNameId the class name ID
4175            * @param templateId the template ID
4176            * @throws SystemException if a system exception occurred
4177            */
4178            public static void removeByG_C_T(long groupId, long classNameId,
4179                    java.lang.String templateId)
4180                    throws com.liferay.portal.kernel.exception.SystemException {
4181                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
4182            }
4183    
4184            /**
4185            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
4186            *
4187            * @param groupId the group ID
4188            * @param classNameId the class name ID
4189            * @param layoutUuid the layout uuid
4190            * @throws SystemException if a system exception occurred
4191            */
4192            public static void removeByG_C_L(long groupId, long classNameId,
4193                    java.lang.String layoutUuid)
4194                    throws com.liferay.portal.kernel.exception.SystemException {
4195                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
4196            }
4197    
4198            /**
4199            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
4200            *
4201            * @param groupId the group ID
4202            * @param articleId the article ID
4203            * @param version the version
4204            * @throws SystemException if a system exception occurred
4205            */
4206            public static void removeByG_A_V(long groupId, java.lang.String articleId,
4207                    double version)
4208                    throws com.liferay.portal.kernel.exception.SystemException,
4209                            com.liferay.portlet.journal.NoSuchArticleException {
4210                    getPersistence().removeByG_A_V(groupId, articleId, version);
4211            }
4212    
4213            /**
4214            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
4215            *
4216            * @param groupId the group ID
4217            * @param articleId the article ID
4218            * @param status the status
4219            * @throws SystemException if a system exception occurred
4220            */
4221            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
4222                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4223                    getPersistence().removeByG_A_ST(groupId, articleId, status);
4224            }
4225    
4226            /**
4227            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
4228            *
4229            * @param groupId the group ID
4230            * @param urlTitle the url title
4231            * @param status the status
4232            * @throws SystemException if a system exception occurred
4233            */
4234            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
4235                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4236                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
4237            }
4238    
4239            /**
4240            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
4241            *
4242            * @param companyId the company ID
4243            * @param version the version
4244            * @param status the status
4245            * @throws SystemException if a system exception occurred
4246            */
4247            public static void removeByC_V_ST(long companyId, double version, int status)
4248                    throws com.liferay.portal.kernel.exception.SystemException {
4249                    getPersistence().removeByC_V_ST(companyId, version, status);
4250            }
4251    
4252            /**
4253            * Removes all the journal articles from the database.
4254            *
4255            * @throws SystemException if a system exception occurred
4256            */
4257            public static void removeAll()
4258                    throws com.liferay.portal.kernel.exception.SystemException {
4259                    getPersistence().removeAll();
4260            }
4261    
4262            /**
4263            * Returns the number of journal articles where uuid = &#63;.
4264            *
4265            * @param uuid the uuid
4266            * @return the number of matching journal articles
4267            * @throws SystemException if a system exception occurred
4268            */
4269            public static int countByUuid(java.lang.String uuid)
4270                    throws com.liferay.portal.kernel.exception.SystemException {
4271                    return getPersistence().countByUuid(uuid);
4272            }
4273    
4274            /**
4275            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
4276            *
4277            * @param uuid the uuid
4278            * @param groupId the group ID
4279            * @return the number of matching journal articles
4280            * @throws SystemException if a system exception occurred
4281            */
4282            public static int countByUUID_G(java.lang.String uuid, long groupId)
4283                    throws com.liferay.portal.kernel.exception.SystemException {
4284                    return getPersistence().countByUUID_G(uuid, groupId);
4285            }
4286    
4287            /**
4288            * Returns the number of journal articles where resourcePrimKey = &#63;.
4289            *
4290            * @param resourcePrimKey the resource prim key
4291            * @return the number of matching journal articles
4292            * @throws SystemException if a system exception occurred
4293            */
4294            public static int countByResourcePrimKey(long resourcePrimKey)
4295                    throws com.liferay.portal.kernel.exception.SystemException {
4296                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
4297            }
4298    
4299            /**
4300            * Returns the number of journal articles where groupId = &#63;.
4301            *
4302            * @param groupId the group ID
4303            * @return the number of matching journal articles
4304            * @throws SystemException if a system exception occurred
4305            */
4306            public static int countByGroupId(long groupId)
4307                    throws com.liferay.portal.kernel.exception.SystemException {
4308                    return getPersistence().countByGroupId(groupId);
4309            }
4310    
4311            /**
4312            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
4313            *
4314            * @param groupId the group ID
4315            * @return the number of matching journal articles that the user has permission to view
4316            * @throws SystemException if a system exception occurred
4317            */
4318            public static int filterCountByGroupId(long groupId)
4319                    throws com.liferay.portal.kernel.exception.SystemException {
4320                    return getPersistence().filterCountByGroupId(groupId);
4321            }
4322    
4323            /**
4324            * Returns the number of journal articles where companyId = &#63;.
4325            *
4326            * @param companyId the company ID
4327            * @return the number of matching journal articles
4328            * @throws SystemException if a system exception occurred
4329            */
4330            public static int countByCompanyId(long companyId)
4331                    throws com.liferay.portal.kernel.exception.SystemException {
4332                    return getPersistence().countByCompanyId(companyId);
4333            }
4334    
4335            /**
4336            * Returns the number of journal articles where smallImageId = &#63;.
4337            *
4338            * @param smallImageId the small image ID
4339            * @return the number of matching journal articles
4340            * @throws SystemException if a system exception occurred
4341            */
4342            public static int countBySmallImageId(long smallImageId)
4343                    throws com.liferay.portal.kernel.exception.SystemException {
4344                    return getPersistence().countBySmallImageId(smallImageId);
4345            }
4346    
4347            /**
4348            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
4349            *
4350            * @param resourcePrimKey the resource prim key
4351            * @param status the status
4352            * @return the number of matching journal articles
4353            * @throws SystemException if a system exception occurred
4354            */
4355            public static int countByR_ST(long resourcePrimKey, int status)
4356                    throws com.liferay.portal.kernel.exception.SystemException {
4357                    return getPersistence().countByR_ST(resourcePrimKey, status);
4358            }
4359    
4360            /**
4361            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
4362            *
4363            * @param groupId the group ID
4364            * @param articleId the article ID
4365            * @return the number of matching journal articles
4366            * @throws SystemException if a system exception occurred
4367            */
4368            public static int countByG_A(long groupId, java.lang.String articleId)
4369                    throws com.liferay.portal.kernel.exception.SystemException {
4370                    return getPersistence().countByG_A(groupId, articleId);
4371            }
4372    
4373            /**
4374            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
4375            *
4376            * @param groupId the group ID
4377            * @param articleId the article ID
4378            * @return the number of matching journal articles that the user has permission to view
4379            * @throws SystemException if a system exception occurred
4380            */
4381            public static int filterCountByG_A(long groupId, java.lang.String articleId)
4382                    throws com.liferay.portal.kernel.exception.SystemException {
4383                    return getPersistence().filterCountByG_A(groupId, articleId);
4384            }
4385    
4386            /**
4387            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
4388            *
4389            * @param groupId the group ID
4390            * @param urlTitle the url title
4391            * @return the number of matching journal articles
4392            * @throws SystemException if a system exception occurred
4393            */
4394            public static int countByG_UT(long groupId, java.lang.String urlTitle)
4395                    throws com.liferay.portal.kernel.exception.SystemException {
4396                    return getPersistence().countByG_UT(groupId, urlTitle);
4397            }
4398    
4399            /**
4400            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
4401            *
4402            * @param groupId the group ID
4403            * @param urlTitle the url title
4404            * @return the number of matching journal articles that the user has permission to view
4405            * @throws SystemException if a system exception occurred
4406            */
4407            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
4408                    throws com.liferay.portal.kernel.exception.SystemException {
4409                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
4410            }
4411    
4412            /**
4413            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
4414            *
4415            * @param groupId the group ID
4416            * @param structureId the structure ID
4417            * @return the number of matching journal articles
4418            * @throws SystemException if a system exception occurred
4419            */
4420            public static int countByG_S(long groupId, java.lang.String structureId)
4421                    throws com.liferay.portal.kernel.exception.SystemException {
4422                    return getPersistence().countByG_S(groupId, structureId);
4423            }
4424    
4425            /**
4426            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
4427            *
4428            * @param groupId the group ID
4429            * @param structureId the structure ID
4430            * @return the number of matching journal articles that the user has permission to view
4431            * @throws SystemException if a system exception occurred
4432            */
4433            public static int filterCountByG_S(long groupId,
4434                    java.lang.String structureId)
4435                    throws com.liferay.portal.kernel.exception.SystemException {
4436                    return getPersistence().filterCountByG_S(groupId, structureId);
4437            }
4438    
4439            /**
4440            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
4441            *
4442            * @param groupId the group ID
4443            * @param templateId the template ID
4444            * @return the number of matching journal articles
4445            * @throws SystemException if a system exception occurred
4446            */
4447            public static int countByG_T(long groupId, java.lang.String templateId)
4448                    throws com.liferay.portal.kernel.exception.SystemException {
4449                    return getPersistence().countByG_T(groupId, templateId);
4450            }
4451    
4452            /**
4453            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
4454            *
4455            * @param groupId the group ID
4456            * @param templateId the template ID
4457            * @return the number of matching journal articles that the user has permission to view
4458            * @throws SystemException if a system exception occurred
4459            */
4460            public static int filterCountByG_T(long groupId, java.lang.String templateId)
4461                    throws com.liferay.portal.kernel.exception.SystemException {
4462                    return getPersistence().filterCountByG_T(groupId, templateId);
4463            }
4464    
4465            /**
4466            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4467            *
4468            * @param groupId the group ID
4469            * @param layoutUuid the layout uuid
4470            * @return the number of matching journal articles
4471            * @throws SystemException if a system exception occurred
4472            */
4473            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4474                    throws com.liferay.portal.kernel.exception.SystemException {
4475                    return getPersistence().countByG_L(groupId, layoutUuid);
4476            }
4477    
4478            /**
4479            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4480            *
4481            * @param groupId the group ID
4482            * @param layoutUuid the layout uuid
4483            * @return the number of matching journal articles that the user has permission to view
4484            * @throws SystemException if a system exception occurred
4485            */
4486            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4487                    throws com.liferay.portal.kernel.exception.SystemException {
4488                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4489            }
4490    
4491            /**
4492            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4493            *
4494            * @param groupId the group ID
4495            * @param status the status
4496            * @return the number of matching journal articles
4497            * @throws SystemException if a system exception occurred
4498            */
4499            public static int countByG_ST(long groupId, int status)
4500                    throws com.liferay.portal.kernel.exception.SystemException {
4501                    return getPersistence().countByG_ST(groupId, status);
4502            }
4503    
4504            /**
4505            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4506            *
4507            * @param groupId the group ID
4508            * @param status the status
4509            * @return the number of matching journal articles that the user has permission to view
4510            * @throws SystemException if a system exception occurred
4511            */
4512            public static int filterCountByG_ST(long groupId, int status)
4513                    throws com.liferay.portal.kernel.exception.SystemException {
4514                    return getPersistence().filterCountByG_ST(groupId, status);
4515            }
4516    
4517            /**
4518            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4519            *
4520            * @param companyId the company ID
4521            * @param version the version
4522            * @return the number of matching journal articles
4523            * @throws SystemException if a system exception occurred
4524            */
4525            public static int countByC_V(long companyId, double version)
4526                    throws com.liferay.portal.kernel.exception.SystemException {
4527                    return getPersistence().countByC_V(companyId, version);
4528            }
4529    
4530            /**
4531            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4532            *
4533            * @param companyId the company ID
4534            * @param status the status
4535            * @return the number of matching journal articles
4536            * @throws SystemException if a system exception occurred
4537            */
4538            public static int countByC_ST(long companyId, int status)
4539                    throws com.liferay.portal.kernel.exception.SystemException {
4540                    return getPersistence().countByC_ST(companyId, status);
4541            }
4542    
4543            /**
4544            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4545            *
4546            * @param groupId the group ID
4547            * @param classNameId the class name ID
4548            * @param classPK the class p k
4549            * @return the number of matching journal articles
4550            * @throws SystemException if a system exception occurred
4551            */
4552            public static int countByG_C_C(long groupId, long classNameId, long classPK)
4553                    throws com.liferay.portal.kernel.exception.SystemException {
4554                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
4555            }
4556    
4557            /**
4558            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4559            *
4560            * @param groupId the group ID
4561            * @param classNameId the class name ID
4562            * @param classPK the class p k
4563            * @return the number of matching journal articles that the user has permission to view
4564            * @throws SystemException if a system exception occurred
4565            */
4566            public static int filterCountByG_C_C(long groupId, long classNameId,
4567                    long classPK)
4568                    throws com.liferay.portal.kernel.exception.SystemException {
4569                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
4570            }
4571    
4572            /**
4573            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
4574            *
4575            * @param groupId the group ID
4576            * @param classNameId the class name ID
4577            * @param structureId the structure ID
4578            * @return the number of matching journal articles
4579            * @throws SystemException if a system exception occurred
4580            */
4581            public static int countByG_C_S(long groupId, long classNameId,
4582                    java.lang.String structureId)
4583                    throws com.liferay.portal.kernel.exception.SystemException {
4584                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
4585            }
4586    
4587            /**
4588            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
4589            *
4590            * @param groupId the group ID
4591            * @param classNameId the class name ID
4592            * @param templateId the template ID
4593            * @return the number of matching journal articles
4594            * @throws SystemException if a system exception occurred
4595            */
4596            public static int countByG_C_T(long groupId, long classNameId,
4597                    java.lang.String templateId)
4598                    throws com.liferay.portal.kernel.exception.SystemException {
4599                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
4600            }
4601    
4602            /**
4603            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
4604            *
4605            * @param groupId the group ID
4606            * @param classNameId the class name ID
4607            * @param templateId the template ID
4608            * @return the number of matching journal articles that the user has permission to view
4609            * @throws SystemException if a system exception occurred
4610            */
4611            public static int filterCountByG_C_T(long groupId, long classNameId,
4612                    java.lang.String templateId)
4613                    throws com.liferay.portal.kernel.exception.SystemException {
4614                    return getPersistence()
4615                                       .filterCountByG_C_T(groupId, classNameId, templateId);
4616            }
4617    
4618            /**
4619            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
4620            *
4621            * @param groupId the group ID
4622            * @param classNameId the class name ID
4623            * @param layoutUuid the layout uuid
4624            * @return the number of matching journal articles
4625            * @throws SystemException if a system exception occurred
4626            */
4627            public static int countByG_C_L(long groupId, long classNameId,
4628                    java.lang.String layoutUuid)
4629                    throws com.liferay.portal.kernel.exception.SystemException {
4630                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
4631            }
4632    
4633            /**
4634            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
4635            *
4636            * @param groupId the group ID
4637            * @param classNameId the class name ID
4638            * @param layoutUuid the layout uuid
4639            * @return the number of matching journal articles that the user has permission to view
4640            * @throws SystemException if a system exception occurred
4641            */
4642            public static int filterCountByG_C_L(long groupId, long classNameId,
4643                    java.lang.String layoutUuid)
4644                    throws com.liferay.portal.kernel.exception.SystemException {
4645                    return getPersistence()
4646                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
4647            }
4648    
4649            /**
4650            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
4651            *
4652            * @param groupId the group ID
4653            * @param articleId the article ID
4654            * @param version the version
4655            * @return the number of matching journal articles
4656            * @throws SystemException if a system exception occurred
4657            */
4658            public static int countByG_A_V(long groupId, java.lang.String articleId,
4659                    double version)
4660                    throws com.liferay.portal.kernel.exception.SystemException {
4661                    return getPersistence().countByG_A_V(groupId, articleId, version);
4662            }
4663    
4664            /**
4665            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
4666            *
4667            * @param groupId the group ID
4668            * @param articleId the article ID
4669            * @param status the status
4670            * @return the number of matching journal articles
4671            * @throws SystemException if a system exception occurred
4672            */
4673            public static int countByG_A_ST(long groupId, java.lang.String articleId,
4674                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4675                    return getPersistence().countByG_A_ST(groupId, articleId, status);
4676            }
4677    
4678            /**
4679            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
4680            *
4681            * @param groupId the group ID
4682            * @param articleId the article ID
4683            * @param status the status
4684            * @return the number of matching journal articles that the user has permission to view
4685            * @throws SystemException if a system exception occurred
4686            */
4687            public static int filterCountByG_A_ST(long groupId,
4688                    java.lang.String articleId, int status)
4689                    throws com.liferay.portal.kernel.exception.SystemException {
4690                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
4691            }
4692    
4693            /**
4694            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4695            *
4696            * @param groupId the group ID
4697            * @param urlTitle the url title
4698            * @param status the status
4699            * @return the number of matching journal articles
4700            * @throws SystemException if a system exception occurred
4701            */
4702            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
4703                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4704                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
4705            }
4706    
4707            /**
4708            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4709            *
4710            * @param groupId the group ID
4711            * @param urlTitle the url title
4712            * @param status the status
4713            * @return the number of matching journal articles that the user has permission to view
4714            * @throws SystemException if a system exception occurred
4715            */
4716            public static int filterCountByG_UT_ST(long groupId,
4717                    java.lang.String urlTitle, int status)
4718                    throws com.liferay.portal.kernel.exception.SystemException {
4719                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
4720            }
4721    
4722            /**
4723            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4724            *
4725            * @param companyId the company ID
4726            * @param version the version
4727            * @param status the status
4728            * @return the number of matching journal articles
4729            * @throws SystemException if a system exception occurred
4730            */
4731            public static int countByC_V_ST(long companyId, double version, int status)
4732                    throws com.liferay.portal.kernel.exception.SystemException {
4733                    return getPersistence().countByC_V_ST(companyId, version, status);
4734            }
4735    
4736            /**
4737            * Returns the number of journal articles.
4738            *
4739            * @return the number of journal articles
4740            * @throws SystemException if a system exception occurred
4741            */
4742            public static int countAll()
4743                    throws com.liferay.portal.kernel.exception.SystemException {
4744                    return getPersistence().countAll();
4745            }
4746    
4747            public static JournalArticlePersistence getPersistence() {
4748                    if (_persistence == null) {
4749                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
4750    
4751                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
4752                                    "_persistence");
4753                    }
4754    
4755                    return _persistence;
4756            }
4757    
4758            public void setPersistence(JournalArticlePersistence persistence) {
4759                    _persistence = persistence;
4760    
4761                    ReferenceRegistry.registerReference(JournalArticleUtil.class,
4762                            "_persistence");
4763            }
4764    
4765            private static JournalArticlePersistence _persistence;
4766    }