001    /**
002     * Copyright (c) 2000-2012 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#update(com.liferay.portal.model.BaseModel, boolean)
099             */
100            public static JournalArticle update(JournalArticle journalArticle,
101                    boolean merge) throws SystemException {
102                    return getPersistence().update(journalArticle, merge);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
107             */
108            public static JournalArticle update(JournalArticle journalArticle,
109                    boolean merge, ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(journalArticle, merge, serviceContext);
111            }
112    
113            /**
114            * Caches the journal article in the entity cache if it is enabled.
115            *
116            * @param journalArticle the journal article
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
120                    getPersistence().cacheResult(journalArticle);
121            }
122    
123            /**
124            * Caches the journal articles in the entity cache if it is enabled.
125            *
126            * @param journalArticles the journal articles
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
130                    getPersistence().cacheResult(journalArticles);
131            }
132    
133            /**
134            * Creates a new journal article with the primary key. Does not add the journal article to the database.
135            *
136            * @param id the primary key for the new journal article
137            * @return the new journal article
138            */
139            public static com.liferay.portlet.journal.model.JournalArticle create(
140                    long id) {
141                    return getPersistence().create(id);
142            }
143    
144            /**
145            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
146            *
147            * @param id the primary key of the journal article
148            * @return the journal article that was removed
149            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
150            * @throws SystemException if a system exception occurred
151            */
152            public static com.liferay.portlet.journal.model.JournalArticle remove(
153                    long id)
154                    throws com.liferay.portal.kernel.exception.SystemException,
155                            com.liferay.portlet.journal.NoSuchArticleException {
156                    return getPersistence().remove(id);
157            }
158    
159            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
160                    com.liferay.portlet.journal.model.JournalArticle journalArticle,
161                    boolean merge)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().updateImpl(journalArticle, merge);
164            }
165    
166            /**
167            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
168            *
169            * @param id the primary key of the journal article
170            * @return the journal article
171            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
175                    long id)
176                    throws com.liferay.portal.kernel.exception.SystemException,
177                            com.liferay.portlet.journal.NoSuchArticleException {
178                    return getPersistence().findByPrimaryKey(id);
179            }
180    
181            /**
182            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
183            *
184            * @param id the primary key of the journal article
185            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
186            * @throws SystemException if a system exception occurred
187            */
188            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
189                    long id) throws com.liferay.portal.kernel.exception.SystemException {
190                    return getPersistence().fetchByPrimaryKey(id);
191            }
192    
193            /**
194            * Returns all the journal articles where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @return the matching journal articles
198            * @throws SystemException if a system exception occurred
199            */
200            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
201                    java.lang.String uuid)
202                    throws com.liferay.portal.kernel.exception.SystemException {
203                    return getPersistence().findByUuid(uuid);
204            }
205    
206            /**
207            * Returns a range of all the journal articles where uuid = &#63;.
208            *
209            * <p>
210            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
211            * </p>
212            *
213            * @param uuid the uuid
214            * @param start the lower bound of the range of journal articles
215            * @param end the upper bound of the range of journal articles (not inclusive)
216            * @return the range of matching journal articles
217            * @throws SystemException if a system exception occurred
218            */
219            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
220                    java.lang.String uuid, int start, int end)
221                    throws com.liferay.portal.kernel.exception.SystemException {
222                    return getPersistence().findByUuid(uuid, start, end);
223            }
224    
225            /**
226            * Returns an ordered range of all the journal articles where uuid = &#63;.
227            *
228            * <p>
229            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
230            * </p>
231            *
232            * @param uuid the uuid
233            * @param start the lower bound of the range of journal articles
234            * @param end the upper bound of the range of journal articles (not inclusive)
235            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
236            * @return the ordered range of matching journal articles
237            * @throws SystemException if a system exception occurred
238            */
239            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
240                    java.lang.String uuid, int start, int end,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.kernel.exception.SystemException {
243                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
244            }
245    
246            /**
247            * Returns the first journal article in the ordered set where uuid = &#63;.
248            *
249            * @param uuid the uuid
250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
251            * @return the first matching journal article
252            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
253            * @throws SystemException if a system exception occurred
254            */
255            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
256                    java.lang.String uuid,
257                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
258                    throws com.liferay.portal.kernel.exception.SystemException,
259                            com.liferay.portlet.journal.NoSuchArticleException {
260                    return getPersistence().findByUuid_First(uuid, orderByComparator);
261            }
262    
263            /**
264            * Returns the first journal article in the ordered set where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
268            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
269            * @throws SystemException if a system exception occurred
270            */
271            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First(
272                    java.lang.String uuid,
273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
274                    throws com.liferay.portal.kernel.exception.SystemException {
275                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
276            }
277    
278            /**
279            * Returns the last journal article in the ordered set where uuid = &#63;.
280            *
281            * @param uuid the uuid
282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
283            * @return the last matching journal article
284            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
285            * @throws SystemException if a system exception occurred
286            */
287            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
288                    java.lang.String uuid,
289                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
290                    throws com.liferay.portal.kernel.exception.SystemException,
291                            com.liferay.portlet.journal.NoSuchArticleException {
292                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
293            }
294    
295            /**
296            * Returns the last journal article in the ordered set where uuid = &#63;.
297            *
298            * @param uuid the uuid
299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
300            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
301            * @throws SystemException if a system exception occurred
302            */
303            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last(
304                    java.lang.String uuid,
305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
306                    throws com.liferay.portal.kernel.exception.SystemException {
307                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
308            }
309    
310            /**
311            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
312            *
313            * @param id the primary key of the current journal article
314            * @param uuid the uuid
315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
316            * @return the previous, current, and next journal article
317            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
318            * @throws SystemException if a system exception occurred
319            */
320            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
321                    long id, java.lang.String uuid,
322                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
323                    throws com.liferay.portal.kernel.exception.SystemException,
324                            com.liferay.portlet.journal.NoSuchArticleException {
325                    return getPersistence()
326                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
327            }
328    
329            /**
330            * 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.
331            *
332            * @param uuid the uuid
333            * @param groupId the group ID
334            * @return the matching journal article
335            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
336            * @throws SystemException if a system exception occurred
337            */
338            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
339                    java.lang.String uuid, long groupId)
340                    throws com.liferay.portal.kernel.exception.SystemException,
341                            com.liferay.portlet.journal.NoSuchArticleException {
342                    return getPersistence().findByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * 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.
347            *
348            * @param uuid the uuid
349            * @param groupId the group ID
350            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
351            * @throws SystemException if a system exception occurred
352            */
353            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
354                    java.lang.String uuid, long groupId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().fetchByUUID_G(uuid, groupId);
357            }
358    
359            /**
360            * 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.
361            *
362            * @param uuid the uuid
363            * @param groupId the group ID
364            * @param retrieveFromCache whether to use the finder cache
365            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
366            * @throws SystemException if a system exception occurred
367            */
368            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
369                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
370                    throws com.liferay.portal.kernel.exception.SystemException {
371                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
372            }
373    
374            /**
375            * Returns all the journal articles where resourcePrimKey = &#63;.
376            *
377            * @param resourcePrimKey the resource prim key
378            * @return the matching journal articles
379            * @throws SystemException if a system exception occurred
380            */
381            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
382                    long resourcePrimKey)
383                    throws com.liferay.portal.kernel.exception.SystemException {
384                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
385            }
386    
387            /**
388            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
389            *
390            * <p>
391            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
392            * </p>
393            *
394            * @param resourcePrimKey the resource prim key
395            * @param start the lower bound of the range of journal articles
396            * @param end the upper bound of the range of journal articles (not inclusive)
397            * @return the range of matching journal articles
398            * @throws SystemException if a system exception occurred
399            */
400            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
401                    long resourcePrimKey, int start, int end)
402                    throws com.liferay.portal.kernel.exception.SystemException {
403                    return getPersistence()
404                                       .findByResourcePrimKey(resourcePrimKey, start, end);
405            }
406    
407            /**
408            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
409            *
410            * <p>
411            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
412            * </p>
413            *
414            * @param resourcePrimKey the resource prim key
415            * @param start the lower bound of the range of journal articles
416            * @param end the upper bound of the range of journal articles (not inclusive)
417            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
418            * @return the ordered range of matching journal articles
419            * @throws SystemException if a system exception occurred
420            */
421            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
422                    long resourcePrimKey, int start, int end,
423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
424                    throws com.liferay.portal.kernel.exception.SystemException {
425                    return getPersistence()
426                                       .findByResourcePrimKey(resourcePrimKey, start, end,
427                            orderByComparator);
428            }
429    
430            /**
431            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
432            *
433            * @param resourcePrimKey the resource prim key
434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
435            * @return the first matching journal article
436            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
437            * @throws SystemException if a system exception occurred
438            */
439            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
440                    long resourcePrimKey,
441                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
442                    throws com.liferay.portal.kernel.exception.SystemException,
443                            com.liferay.portlet.journal.NoSuchArticleException {
444                    return getPersistence()
445                                       .findByResourcePrimKey_First(resourcePrimKey,
446                            orderByComparator);
447            }
448    
449            /**
450            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
451            *
452            * @param resourcePrimKey the resource prim key
453            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
454            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
455            * @throws SystemException if a system exception occurred
456            */
457            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First(
458                    long resourcePrimKey,
459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
460                    throws com.liferay.portal.kernel.exception.SystemException {
461                    return getPersistence()
462                                       .fetchByResourcePrimKey_First(resourcePrimKey,
463                            orderByComparator);
464            }
465    
466            /**
467            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
468            *
469            * @param resourcePrimKey the resource prim key
470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
471            * @return the last matching journal article
472            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
473            * @throws SystemException if a system exception occurred
474            */
475            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
476                    long resourcePrimKey,
477                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
478                    throws com.liferay.portal.kernel.exception.SystemException,
479                            com.liferay.portlet.journal.NoSuchArticleException {
480                    return getPersistence()
481                                       .findByResourcePrimKey_Last(resourcePrimKey,
482                            orderByComparator);
483            }
484    
485            /**
486            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
487            *
488            * @param resourcePrimKey the resource prim key
489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
490            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
491            * @throws SystemException if a system exception occurred
492            */
493            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last(
494                    long resourcePrimKey,
495                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
496                    throws com.liferay.portal.kernel.exception.SystemException {
497                    return getPersistence()
498                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
499                            orderByComparator);
500            }
501    
502            /**
503            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
504            *
505            * @param id the primary key of the current journal article
506            * @param resourcePrimKey the resource prim key
507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
508            * @return the previous, current, and next journal article
509            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
510            * @throws SystemException if a system exception occurred
511            */
512            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
513                    long id, long resourcePrimKey,
514                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
515                    throws com.liferay.portal.kernel.exception.SystemException,
516                            com.liferay.portlet.journal.NoSuchArticleException {
517                    return getPersistence()
518                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
519                            orderByComparator);
520            }
521    
522            /**
523            * Returns all the journal articles where groupId = &#63;.
524            *
525            * @param groupId the group ID
526            * @return the matching journal articles
527            * @throws SystemException if a system exception occurred
528            */
529            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
530                    long groupId)
531                    throws com.liferay.portal.kernel.exception.SystemException {
532                    return getPersistence().findByGroupId(groupId);
533            }
534    
535            /**
536            * Returns a range of all the journal articles where groupId = &#63;.
537            *
538            * <p>
539            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
540            * </p>
541            *
542            * @param groupId the group ID
543            * @param start the lower bound of the range of journal articles
544            * @param end the upper bound of the range of journal articles (not inclusive)
545            * @return the range of matching journal articles
546            * @throws SystemException if a system exception occurred
547            */
548            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
549                    long groupId, int start, int end)
550                    throws com.liferay.portal.kernel.exception.SystemException {
551                    return getPersistence().findByGroupId(groupId, start, end);
552            }
553    
554            /**
555            * Returns an ordered range of all the journal articles where groupId = &#63;.
556            *
557            * <p>
558            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
559            * </p>
560            *
561            * @param groupId the group ID
562            * @param start the lower bound of the range of journal articles
563            * @param end the upper bound of the range of journal articles (not inclusive)
564            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
565            * @return the ordered range of matching journal articles
566            * @throws SystemException if a system exception occurred
567            */
568            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
569                    long groupId, int start, int end,
570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
571                    throws com.liferay.portal.kernel.exception.SystemException {
572                    return getPersistence()
573                                       .findByGroupId(groupId, start, end, orderByComparator);
574            }
575    
576            /**
577            * Returns the first journal article in the ordered set where groupId = &#63;.
578            *
579            * @param groupId the group ID
580            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
581            * @return the first matching journal article
582            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
583            * @throws SystemException if a system exception occurred
584            */
585            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
586                    long groupId,
587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
588                    throws com.liferay.portal.kernel.exception.SystemException,
589                            com.liferay.portlet.journal.NoSuchArticleException {
590                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
591            }
592    
593            /**
594            * Returns the first journal article in the ordered set where groupId = &#63;.
595            *
596            * @param groupId the group ID
597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
598            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
599            * @throws SystemException if a system exception occurred
600            */
601            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First(
602                    long groupId,
603                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
604                    throws com.liferay.portal.kernel.exception.SystemException {
605                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
606            }
607    
608            /**
609            * Returns the last journal article in the ordered set where groupId = &#63;.
610            *
611            * @param groupId the group ID
612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
613            * @return the last matching journal article
614            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
615            * @throws SystemException if a system exception occurred
616            */
617            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
618                    long groupId,
619                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
620                    throws com.liferay.portal.kernel.exception.SystemException,
621                            com.liferay.portlet.journal.NoSuchArticleException {
622                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
623            }
624    
625            /**
626            * Returns the last journal article in the ordered set where groupId = &#63;.
627            *
628            * @param groupId the group ID
629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
630            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
631            * @throws SystemException if a system exception occurred
632            */
633            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last(
634                    long groupId,
635                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
636                    throws com.liferay.portal.kernel.exception.SystemException {
637                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
638            }
639    
640            /**
641            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
642            *
643            * @param id the primary key of the current journal article
644            * @param groupId the group ID
645            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
646            * @return the previous, current, and next journal article
647            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
648            * @throws SystemException if a system exception occurred
649            */
650            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
651                    long id, long groupId,
652                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
653                    throws com.liferay.portal.kernel.exception.SystemException,
654                            com.liferay.portlet.journal.NoSuchArticleException {
655                    return getPersistence()
656                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
657            }
658    
659            /**
660            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
661            *
662            * @param groupId the group ID
663            * @return the matching journal articles that the user has permission to view
664            * @throws SystemException if a system exception occurred
665            */
666            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
667                    long groupId)
668                    throws com.liferay.portal.kernel.exception.SystemException {
669                    return getPersistence().filterFindByGroupId(groupId);
670            }
671    
672            /**
673            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
674            *
675            * <p>
676            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
677            * </p>
678            *
679            * @param groupId the group ID
680            * @param start the lower bound of the range of journal articles
681            * @param end the upper bound of the range of journal articles (not inclusive)
682            * @return the range of matching journal articles that the user has permission to view
683            * @throws SystemException if a system exception occurred
684            */
685            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
686                    long groupId, int start, int end)
687                    throws com.liferay.portal.kernel.exception.SystemException {
688                    return getPersistence().filterFindByGroupId(groupId, start, end);
689            }
690    
691            /**
692            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
693            *
694            * <p>
695            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
696            * </p>
697            *
698            * @param groupId the group ID
699            * @param start the lower bound of the range of journal articles
700            * @param end the upper bound of the range of journal articles (not inclusive)
701            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
702            * @return the ordered range of matching journal articles that the user has permission to view
703            * @throws SystemException if a system exception occurred
704            */
705            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
706                    long groupId, int start, int end,
707                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
708                    throws com.liferay.portal.kernel.exception.SystemException {
709                    return getPersistence()
710                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
711            }
712    
713            /**
714            * 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;.
715            *
716            * @param id the primary key of the current journal article
717            * @param groupId the group ID
718            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
719            * @return the previous, current, and next journal article
720            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
721            * @throws SystemException if a system exception occurred
722            */
723            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
724                    long id, long groupId,
725                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
726                    throws com.liferay.portal.kernel.exception.SystemException,
727                            com.liferay.portlet.journal.NoSuchArticleException {
728                    return getPersistence()
729                                       .filterFindByGroupId_PrevAndNext(id, groupId,
730                            orderByComparator);
731            }
732    
733            /**
734            * Returns all the journal articles where companyId = &#63;.
735            *
736            * @param companyId the company ID
737            * @return the matching journal articles
738            * @throws SystemException if a system exception occurred
739            */
740            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
741                    long companyId)
742                    throws com.liferay.portal.kernel.exception.SystemException {
743                    return getPersistence().findByCompanyId(companyId);
744            }
745    
746            /**
747            * Returns a range of all the journal articles where companyId = &#63;.
748            *
749            * <p>
750            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
751            * </p>
752            *
753            * @param companyId the company ID
754            * @param start the lower bound of the range of journal articles
755            * @param end the upper bound of the range of journal articles (not inclusive)
756            * @return the range of matching journal articles
757            * @throws SystemException if a system exception occurred
758            */
759            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
760                    long companyId, int start, int end)
761                    throws com.liferay.portal.kernel.exception.SystemException {
762                    return getPersistence().findByCompanyId(companyId, start, end);
763            }
764    
765            /**
766            * Returns an ordered range of all the journal articles where companyId = &#63;.
767            *
768            * <p>
769            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
770            * </p>
771            *
772            * @param companyId the company ID
773            * @param start the lower bound of the range of journal articles
774            * @param end the upper bound of the range of journal articles (not inclusive)
775            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
776            * @return the ordered range of matching journal articles
777            * @throws SystemException if a system exception occurred
778            */
779            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
780                    long companyId, int start, int end,
781                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
782                    throws com.liferay.portal.kernel.exception.SystemException {
783                    return getPersistence()
784                                       .findByCompanyId(companyId, start, end, orderByComparator);
785            }
786    
787            /**
788            * Returns the first journal article in the ordered set where companyId = &#63;.
789            *
790            * @param companyId the company ID
791            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
792            * @return the first matching journal article
793            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
794            * @throws SystemException if a system exception occurred
795            */
796            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
797                    long companyId,
798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
799                    throws com.liferay.portal.kernel.exception.SystemException,
800                            com.liferay.portlet.journal.NoSuchArticleException {
801                    return getPersistence()
802                                       .findByCompanyId_First(companyId, orderByComparator);
803            }
804    
805            /**
806            * Returns the first journal article in the ordered set where companyId = &#63;.
807            *
808            * @param companyId the company ID
809            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
810            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
811            * @throws SystemException if a system exception occurred
812            */
813            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First(
814                    long companyId,
815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
816                    throws com.liferay.portal.kernel.exception.SystemException {
817                    return getPersistence()
818                                       .fetchByCompanyId_First(companyId, orderByComparator);
819            }
820    
821            /**
822            * Returns the last journal article in the ordered set where companyId = &#63;.
823            *
824            * @param companyId the company ID
825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
826            * @return the last matching journal article
827            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
828            * @throws SystemException if a system exception occurred
829            */
830            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
831                    long companyId,
832                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
833                    throws com.liferay.portal.kernel.exception.SystemException,
834                            com.liferay.portlet.journal.NoSuchArticleException {
835                    return getPersistence()
836                                       .findByCompanyId_Last(companyId, orderByComparator);
837            }
838    
839            /**
840            * Returns the last journal article in the ordered set where companyId = &#63;.
841            *
842            * @param companyId the company ID
843            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
844            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
845            * @throws SystemException if a system exception occurred
846            */
847            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last(
848                    long companyId,
849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
850                    throws com.liferay.portal.kernel.exception.SystemException {
851                    return getPersistence()
852                                       .fetchByCompanyId_Last(companyId, orderByComparator);
853            }
854    
855            /**
856            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
857            *
858            * @param id the primary key of the current journal article
859            * @param companyId the company ID
860            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
861            * @return the previous, current, and next journal article
862            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
863            * @throws SystemException if a system exception occurred
864            */
865            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
866                    long id, long companyId,
867                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
868                    throws com.liferay.portal.kernel.exception.SystemException,
869                            com.liferay.portlet.journal.NoSuchArticleException {
870                    return getPersistence()
871                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
872            }
873    
874            /**
875            * Returns all the journal articles where structureId = &#63;.
876            *
877            * @param structureId the structure ID
878            * @return the matching journal articles
879            * @throws SystemException if a system exception occurred
880            */
881            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
882                    java.lang.String structureId)
883                    throws com.liferay.portal.kernel.exception.SystemException {
884                    return getPersistence().findByStructureId(structureId);
885            }
886    
887            /**
888            * Returns a range of all the journal articles where structureId = &#63;.
889            *
890            * <p>
891            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
892            * </p>
893            *
894            * @param structureId the structure ID
895            * @param start the lower bound of the range of journal articles
896            * @param end the upper bound of the range of journal articles (not inclusive)
897            * @return the range of matching journal articles
898            * @throws SystemException if a system exception occurred
899            */
900            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
901                    java.lang.String structureId, int start, int end)
902                    throws com.liferay.portal.kernel.exception.SystemException {
903                    return getPersistence().findByStructureId(structureId, start, end);
904            }
905    
906            /**
907            * Returns an ordered range of all the journal articles where structureId = &#63;.
908            *
909            * <p>
910            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
911            * </p>
912            *
913            * @param structureId the structure ID
914            * @param start the lower bound of the range of journal articles
915            * @param end the upper bound of the range of journal articles (not inclusive)
916            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
917            * @return the ordered range of matching journal articles
918            * @throws SystemException if a system exception occurred
919            */
920            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
921                    java.lang.String structureId, int start, int end,
922                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
923                    throws com.liferay.portal.kernel.exception.SystemException {
924                    return getPersistence()
925                                       .findByStructureId(structureId, start, end, orderByComparator);
926            }
927    
928            /**
929            * Returns the first journal article in the ordered set where structureId = &#63;.
930            *
931            * @param structureId the structure ID
932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
933            * @return the first matching journal article
934            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
935            * @throws SystemException if a system exception occurred
936            */
937            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
938                    java.lang.String structureId,
939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
940                    throws com.liferay.portal.kernel.exception.SystemException,
941                            com.liferay.portlet.journal.NoSuchArticleException {
942                    return getPersistence()
943                                       .findByStructureId_First(structureId, orderByComparator);
944            }
945    
946            /**
947            * Returns the first journal article in the ordered set where structureId = &#63;.
948            *
949            * @param structureId the structure ID
950            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
951            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
952            * @throws SystemException if a system exception occurred
953            */
954            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First(
955                    java.lang.String structureId,
956                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    return getPersistence()
959                                       .fetchByStructureId_First(structureId, orderByComparator);
960            }
961    
962            /**
963            * Returns the last journal article in the ordered set where structureId = &#63;.
964            *
965            * @param structureId the structure ID
966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
967            * @return the last matching journal article
968            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
969            * @throws SystemException if a system exception occurred
970            */
971            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
972                    java.lang.String structureId,
973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
974                    throws com.liferay.portal.kernel.exception.SystemException,
975                            com.liferay.portlet.journal.NoSuchArticleException {
976                    return getPersistence()
977                                       .findByStructureId_Last(structureId, orderByComparator);
978            }
979    
980            /**
981            * Returns the last journal article in the ordered set where structureId = &#63;.
982            *
983            * @param structureId the structure ID
984            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
985            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
986            * @throws SystemException if a system exception occurred
987            */
988            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last(
989                    java.lang.String structureId,
990                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
991                    throws com.liferay.portal.kernel.exception.SystemException {
992                    return getPersistence()
993                                       .fetchByStructureId_Last(structureId, orderByComparator);
994            }
995    
996            /**
997            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
998            *
999            * @param id the primary key of the current journal article
1000            * @param structureId the structure ID
1001            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1002            * @return the previous, current, and next journal article
1003            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1004            * @throws SystemException if a system exception occurred
1005            */
1006            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
1007                    long id, java.lang.String structureId,
1008                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1009                    throws com.liferay.portal.kernel.exception.SystemException,
1010                            com.liferay.portlet.journal.NoSuchArticleException {
1011                    return getPersistence()
1012                                       .findByStructureId_PrevAndNext(id, structureId,
1013                            orderByComparator);
1014            }
1015    
1016            /**
1017            * Returns all the journal articles where templateId = &#63;.
1018            *
1019            * @param templateId the template ID
1020            * @return the matching journal articles
1021            * @throws SystemException if a system exception occurred
1022            */
1023            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1024                    java.lang.String templateId)
1025                    throws com.liferay.portal.kernel.exception.SystemException {
1026                    return getPersistence().findByTemplateId(templateId);
1027            }
1028    
1029            /**
1030            * Returns a range of all the journal articles where templateId = &#63;.
1031            *
1032            * <p>
1033            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1034            * </p>
1035            *
1036            * @param templateId the template ID
1037            * @param start the lower bound of the range of journal articles
1038            * @param end the upper bound of the range of journal articles (not inclusive)
1039            * @return the range of matching journal articles
1040            * @throws SystemException if a system exception occurred
1041            */
1042            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1043                    java.lang.String templateId, int start, int end)
1044                    throws com.liferay.portal.kernel.exception.SystemException {
1045                    return getPersistence().findByTemplateId(templateId, start, end);
1046            }
1047    
1048            /**
1049            * Returns an ordered range of all the journal articles where templateId = &#63;.
1050            *
1051            * <p>
1052            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1053            * </p>
1054            *
1055            * @param templateId the template ID
1056            * @param start the lower bound of the range of journal articles
1057            * @param end the upper bound of the range of journal articles (not inclusive)
1058            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1059            * @return the ordered range of matching journal articles
1060            * @throws SystemException if a system exception occurred
1061            */
1062            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1063                    java.lang.String templateId, int start, int end,
1064                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1065                    throws com.liferay.portal.kernel.exception.SystemException {
1066                    return getPersistence()
1067                                       .findByTemplateId(templateId, start, end, orderByComparator);
1068            }
1069    
1070            /**
1071            * Returns the first journal article in the ordered set where templateId = &#63;.
1072            *
1073            * @param templateId the template ID
1074            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1075            * @return the first matching journal article
1076            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1077            * @throws SystemException if a system exception occurred
1078            */
1079            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1080                    java.lang.String templateId,
1081                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1082                    throws com.liferay.portal.kernel.exception.SystemException,
1083                            com.liferay.portlet.journal.NoSuchArticleException {
1084                    return getPersistence()
1085                                       .findByTemplateId_First(templateId, orderByComparator);
1086            }
1087    
1088            /**
1089            * Returns the first journal article in the ordered set where templateId = &#63;.
1090            *
1091            * @param templateId the template ID
1092            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1093            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1094            * @throws SystemException if a system exception occurred
1095            */
1096            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1097                    java.lang.String templateId,
1098                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1099                    throws com.liferay.portal.kernel.exception.SystemException {
1100                    return getPersistence()
1101                                       .fetchByTemplateId_First(templateId, orderByComparator);
1102            }
1103    
1104            /**
1105            * Returns the last journal article in the ordered set where templateId = &#63;.
1106            *
1107            * @param templateId the template ID
1108            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1109            * @return the last matching journal article
1110            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1111            * @throws SystemException if a system exception occurred
1112            */
1113            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1114                    java.lang.String templateId,
1115                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1116                    throws com.liferay.portal.kernel.exception.SystemException,
1117                            com.liferay.portlet.journal.NoSuchArticleException {
1118                    return getPersistence()
1119                                       .findByTemplateId_Last(templateId, orderByComparator);
1120            }
1121    
1122            /**
1123            * Returns the last journal article in the ordered set where templateId = &#63;.
1124            *
1125            * @param templateId the template ID
1126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1127            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1131                    java.lang.String templateId,
1132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1133                    throws com.liferay.portal.kernel.exception.SystemException {
1134                    return getPersistence()
1135                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1136            }
1137    
1138            /**
1139            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1140            *
1141            * @param id the primary key of the current journal article
1142            * @param templateId the template ID
1143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1144            * @return the previous, current, and next journal article
1145            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1146            * @throws SystemException if a system exception occurred
1147            */
1148            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1149                    long id, java.lang.String templateId,
1150                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1151                    throws com.liferay.portal.kernel.exception.SystemException,
1152                            com.liferay.portlet.journal.NoSuchArticleException {
1153                    return getPersistence()
1154                                       .findByTemplateId_PrevAndNext(id, templateId,
1155                            orderByComparator);
1156            }
1157    
1158            /**
1159            * Returns all the journal articles where smallImageId = &#63;.
1160            *
1161            * @param smallImageId the small image ID
1162            * @return the matching journal articles
1163            * @throws SystemException if a system exception occurred
1164            */
1165            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1166                    long smallImageId)
1167                    throws com.liferay.portal.kernel.exception.SystemException {
1168                    return getPersistence().findBySmallImageId(smallImageId);
1169            }
1170    
1171            /**
1172            * Returns a range of all the journal articles where smallImageId = &#63;.
1173            *
1174            * <p>
1175            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1176            * </p>
1177            *
1178            * @param smallImageId the small image ID
1179            * @param start the lower bound of the range of journal articles
1180            * @param end the upper bound of the range of journal articles (not inclusive)
1181            * @return the range of matching journal articles
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1185                    long smallImageId, int start, int end)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1188            }
1189    
1190            /**
1191            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1192            *
1193            * <p>
1194            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1195            * </p>
1196            *
1197            * @param smallImageId the small image ID
1198            * @param start the lower bound of the range of journal articles
1199            * @param end the upper bound of the range of journal articles (not inclusive)
1200            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1201            * @return the ordered range of matching journal articles
1202            * @throws SystemException if a system exception occurred
1203            */
1204            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1205                    long smallImageId, int start, int end,
1206                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1207                    throws com.liferay.portal.kernel.exception.SystemException {
1208                    return getPersistence()
1209                                       .findBySmallImageId(smallImageId, start, end,
1210                            orderByComparator);
1211            }
1212    
1213            /**
1214            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1215            *
1216            * @param smallImageId the small image ID
1217            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1218            * @return the first matching journal article
1219            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1220            * @throws SystemException if a system exception occurred
1221            */
1222            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1223                    long smallImageId,
1224                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1225                    throws com.liferay.portal.kernel.exception.SystemException,
1226                            com.liferay.portlet.journal.NoSuchArticleException {
1227                    return getPersistence()
1228                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1229            }
1230    
1231            /**
1232            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1233            *
1234            * @param smallImageId the small image ID
1235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1236            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1237            * @throws SystemException if a system exception occurred
1238            */
1239            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1240                    long smallImageId,
1241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1242                    throws com.liferay.portal.kernel.exception.SystemException {
1243                    return getPersistence()
1244                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1245            }
1246    
1247            /**
1248            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1249            *
1250            * @param smallImageId the small image ID
1251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1252            * @return the last matching journal article
1253            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1254            * @throws SystemException if a system exception occurred
1255            */
1256            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1257                    long smallImageId,
1258                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1259                    throws com.liferay.portal.kernel.exception.SystemException,
1260                            com.liferay.portlet.journal.NoSuchArticleException {
1261                    return getPersistence()
1262                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1263            }
1264    
1265            /**
1266            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1267            *
1268            * @param smallImageId the small image ID
1269            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1270            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1271            * @throws SystemException if a system exception occurred
1272            */
1273            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1274                    long smallImageId,
1275                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1276                    throws com.liferay.portal.kernel.exception.SystemException {
1277                    return getPersistence()
1278                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1279            }
1280    
1281            /**
1282            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1283            *
1284            * @param id the primary key of the current journal article
1285            * @param smallImageId the small image ID
1286            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1287            * @return the previous, current, and next journal article
1288            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1289            * @throws SystemException if a system exception occurred
1290            */
1291            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1292                    long id, long smallImageId,
1293                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1294                    throws com.liferay.portal.kernel.exception.SystemException,
1295                            com.liferay.portlet.journal.NoSuchArticleException {
1296                    return getPersistence()
1297                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1298                            orderByComparator);
1299            }
1300    
1301            /**
1302            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1303            *
1304            * @param resourcePrimKey the resource prim key
1305            * @param status the status
1306            * @return the matching journal articles
1307            * @throws SystemException if a system exception occurred
1308            */
1309            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1310                    long resourcePrimKey, int status)
1311                    throws com.liferay.portal.kernel.exception.SystemException {
1312                    return getPersistence().findByR_ST(resourcePrimKey, status);
1313            }
1314    
1315            /**
1316            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1317            *
1318            * <p>
1319            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1320            * </p>
1321            *
1322            * @param resourcePrimKey the resource prim key
1323            * @param status the status
1324            * @param start the lower bound of the range of journal articles
1325            * @param end the upper bound of the range of journal articles (not inclusive)
1326            * @return the range of matching journal articles
1327            * @throws SystemException if a system exception occurred
1328            */
1329            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1330                    long resourcePrimKey, int status, int start, int end)
1331                    throws com.liferay.portal.kernel.exception.SystemException {
1332                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1333            }
1334    
1335            /**
1336            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1337            *
1338            * <p>
1339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1340            * </p>
1341            *
1342            * @param resourcePrimKey the resource prim key
1343            * @param status the status
1344            * @param start the lower bound of the range of journal articles
1345            * @param end the upper bound of the range of journal articles (not inclusive)
1346            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1347            * @return the ordered range of matching journal articles
1348            * @throws SystemException if a system exception occurred
1349            */
1350            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1351                    long resourcePrimKey, int status, int start, int end,
1352                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1353                    throws com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence()
1355                                       .findByR_ST(resourcePrimKey, status, start, end,
1356                            orderByComparator);
1357            }
1358    
1359            /**
1360            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1361            *
1362            * @param resourcePrimKey the resource prim key
1363            * @param status the status
1364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1365            * @return the first matching journal article
1366            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1367            * @throws SystemException if a system exception occurred
1368            */
1369            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1370                    long resourcePrimKey, int status,
1371                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1372                    throws com.liferay.portal.kernel.exception.SystemException,
1373                            com.liferay.portlet.journal.NoSuchArticleException {
1374                    return getPersistence()
1375                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1376            }
1377    
1378            /**
1379            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1380            *
1381            * @param resourcePrimKey the resource prim key
1382            * @param status the status
1383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1384            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1385            * @throws SystemException if a system exception occurred
1386            */
1387            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
1388                    long resourcePrimKey, int status,
1389                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1390                    throws com.liferay.portal.kernel.exception.SystemException {
1391                    return getPersistence()
1392                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
1393            }
1394    
1395            /**
1396            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1397            *
1398            * @param resourcePrimKey the resource prim key
1399            * @param status the status
1400            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1401            * @return the last matching journal article
1402            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1403            * @throws SystemException if a system exception occurred
1404            */
1405            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1406                    long resourcePrimKey, int status,
1407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1408                    throws com.liferay.portal.kernel.exception.SystemException,
1409                            com.liferay.portlet.journal.NoSuchArticleException {
1410                    return getPersistence()
1411                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1412            }
1413    
1414            /**
1415            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1416            *
1417            * @param resourcePrimKey the resource prim key
1418            * @param status the status
1419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1420            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1421            * @throws SystemException if a system exception occurred
1422            */
1423            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
1424                    long resourcePrimKey, int status,
1425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1426                    throws com.liferay.portal.kernel.exception.SystemException {
1427                    return getPersistence()
1428                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
1429            }
1430    
1431            /**
1432            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1433            *
1434            * @param id the primary key of the current journal article
1435            * @param resourcePrimKey the resource prim key
1436            * @param status the status
1437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1438            * @return the previous, current, and next journal article
1439            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1440            * @throws SystemException if a system exception occurred
1441            */
1442            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1443                    long id, long resourcePrimKey, int status,
1444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1445                    throws com.liferay.portal.kernel.exception.SystemException,
1446                            com.liferay.portlet.journal.NoSuchArticleException {
1447                    return getPersistence()
1448                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1449                            orderByComparator);
1450            }
1451    
1452            /**
1453            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
1454            *
1455            * @param groupId the group ID
1456            * @param articleId the article ID
1457            * @return the matching journal articles
1458            * @throws SystemException if a system exception occurred
1459            */
1460            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1461                    long groupId, java.lang.String articleId)
1462                    throws com.liferay.portal.kernel.exception.SystemException {
1463                    return getPersistence().findByG_A(groupId, articleId);
1464            }
1465    
1466            /**
1467            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
1468            *
1469            * <p>
1470            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1471            * </p>
1472            *
1473            * @param groupId the group ID
1474            * @param articleId the article ID
1475            * @param start the lower bound of the range of journal articles
1476            * @param end the upper bound of the range of journal articles (not inclusive)
1477            * @return the range of matching journal articles
1478            * @throws SystemException if a system exception occurred
1479            */
1480            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1481                    long groupId, java.lang.String articleId, int start, int end)
1482                    throws com.liferay.portal.kernel.exception.SystemException {
1483                    return getPersistence().findByG_A(groupId, articleId, start, end);
1484            }
1485    
1486            /**
1487            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
1488            *
1489            * <p>
1490            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1491            * </p>
1492            *
1493            * @param groupId the group ID
1494            * @param articleId the article ID
1495            * @param start the lower bound of the range of journal articles
1496            * @param end the upper bound of the range of journal articles (not inclusive)
1497            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1498            * @return the ordered range of matching journal articles
1499            * @throws SystemException if a system exception occurred
1500            */
1501            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1502                    long groupId, java.lang.String articleId, int start, int end,
1503                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1504                    throws com.liferay.portal.kernel.exception.SystemException {
1505                    return getPersistence()
1506                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
1507            }
1508    
1509            /**
1510            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1511            *
1512            * @param groupId the group ID
1513            * @param articleId the article ID
1514            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1515            * @return the first matching journal article
1516            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1517            * @throws SystemException if a system exception occurred
1518            */
1519            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
1520                    long groupId, java.lang.String articleId,
1521                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1522                    throws com.liferay.portal.kernel.exception.SystemException,
1523                            com.liferay.portlet.journal.NoSuchArticleException {
1524                    return getPersistence()
1525                                       .findByG_A_First(groupId, articleId, orderByComparator);
1526            }
1527    
1528            /**
1529            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1530            *
1531            * @param groupId the group ID
1532            * @param articleId the article ID
1533            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1534            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1535            * @throws SystemException if a system exception occurred
1536            */
1537            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First(
1538                    long groupId, java.lang.String articleId,
1539                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1540                    throws com.liferay.portal.kernel.exception.SystemException {
1541                    return getPersistence()
1542                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
1543            }
1544    
1545            /**
1546            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1547            *
1548            * @param groupId the group ID
1549            * @param articleId the article ID
1550            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1551            * @return the last matching journal article
1552            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1553            * @throws SystemException if a system exception occurred
1554            */
1555            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
1556                    long groupId, java.lang.String articleId,
1557                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1558                    throws com.liferay.portal.kernel.exception.SystemException,
1559                            com.liferay.portlet.journal.NoSuchArticleException {
1560                    return getPersistence()
1561                                       .findByG_A_Last(groupId, articleId, orderByComparator);
1562            }
1563    
1564            /**
1565            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1566            *
1567            * @param groupId the group ID
1568            * @param articleId the article ID
1569            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1570            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1571            * @throws SystemException if a system exception occurred
1572            */
1573            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
1574                    long groupId, java.lang.String articleId,
1575                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1576                    throws com.liferay.portal.kernel.exception.SystemException {
1577                    return getPersistence()
1578                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
1579            }
1580    
1581            /**
1582            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1583            *
1584            * @param id the primary key of the current journal article
1585            * @param groupId the group ID
1586            * @param articleId the article ID
1587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1588            * @return the previous, current, and next journal article
1589            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1590            * @throws SystemException if a system exception occurred
1591            */
1592            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
1593                    long id, long groupId, java.lang.String articleId,
1594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1595                    throws com.liferay.portal.kernel.exception.SystemException,
1596                            com.liferay.portlet.journal.NoSuchArticleException {
1597                    return getPersistence()
1598                                       .findByG_A_PrevAndNext(id, groupId, articleId,
1599                            orderByComparator);
1600            }
1601    
1602            /**
1603            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1604            *
1605            * @param groupId the group ID
1606            * @param articleId the article ID
1607            * @return the matching journal articles that the user has permission to view
1608            * @throws SystemException if a system exception occurred
1609            */
1610            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1611                    long groupId, java.lang.String articleId)
1612                    throws com.liferay.portal.kernel.exception.SystemException {
1613                    return getPersistence().filterFindByG_A(groupId, articleId);
1614            }
1615    
1616            /**
1617            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1618            *
1619            * <p>
1620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1621            * </p>
1622            *
1623            * @param groupId the group ID
1624            * @param articleId the article ID
1625            * @param start the lower bound of the range of journal articles
1626            * @param end the upper bound of the range of journal articles (not inclusive)
1627            * @return the range of matching journal articles that the user has permission to view
1628            * @throws SystemException if a system exception occurred
1629            */
1630            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1631                    long groupId, java.lang.String articleId, int start, int end)
1632                    throws com.liferay.portal.kernel.exception.SystemException {
1633                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
1634            }
1635    
1636            /**
1637            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
1638            *
1639            * <p>
1640            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1641            * </p>
1642            *
1643            * @param groupId the group ID
1644            * @param articleId the article ID
1645            * @param start the lower bound of the range of journal articles
1646            * @param end the upper bound of the range of journal articles (not inclusive)
1647            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1648            * @return the ordered range of matching journal articles that the user has permission to view
1649            * @throws SystemException if a system exception occurred
1650            */
1651            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1652                    long groupId, java.lang.String articleId, int start, int end,
1653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1654                    throws com.liferay.portal.kernel.exception.SystemException {
1655                    return getPersistence()
1656                                       .filterFindByG_A(groupId, articleId, start, end,
1657                            orderByComparator);
1658            }
1659    
1660            /**
1661            * 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;.
1662            *
1663            * @param id the primary key of the current journal article
1664            * @param groupId the group ID
1665            * @param articleId the article ID
1666            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1667            * @return the previous, current, and next journal article
1668            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1669            * @throws SystemException if a system exception occurred
1670            */
1671            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
1672                    long id, long groupId, java.lang.String articleId,
1673                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1674                    throws com.liferay.portal.kernel.exception.SystemException,
1675                            com.liferay.portlet.journal.NoSuchArticleException {
1676                    return getPersistence()
1677                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
1678                            orderByComparator);
1679            }
1680    
1681            /**
1682            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
1683            *
1684            * @param groupId the group ID
1685            * @param urlTitle the url title
1686            * @return the matching journal articles
1687            * @throws SystemException if a system exception occurred
1688            */
1689            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1690                    long groupId, java.lang.String urlTitle)
1691                    throws com.liferay.portal.kernel.exception.SystemException {
1692                    return getPersistence().findByG_UT(groupId, urlTitle);
1693            }
1694    
1695            /**
1696            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1697            *
1698            * <p>
1699            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1700            * </p>
1701            *
1702            * @param groupId the group ID
1703            * @param urlTitle the url title
1704            * @param start the lower bound of the range of journal articles
1705            * @param end the upper bound of the range of journal articles (not inclusive)
1706            * @return the range of matching journal articles
1707            * @throws SystemException if a system exception occurred
1708            */
1709            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1710                    long groupId, java.lang.String urlTitle, int start, int end)
1711                    throws com.liferay.portal.kernel.exception.SystemException {
1712                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
1713            }
1714    
1715            /**
1716            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1717            *
1718            * <p>
1719            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1720            * </p>
1721            *
1722            * @param groupId the group ID
1723            * @param urlTitle the url title
1724            * @param start the lower bound of the range of journal articles
1725            * @param end the upper bound of the range of journal articles (not inclusive)
1726            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1727            * @return the ordered range of matching journal articles
1728            * @throws SystemException if a system exception occurred
1729            */
1730            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1731                    long groupId, java.lang.String urlTitle, int start, int end,
1732                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1733                    throws com.liferay.portal.kernel.exception.SystemException {
1734                    return getPersistence()
1735                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
1736            }
1737    
1738            /**
1739            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1740            *
1741            * @param groupId the group ID
1742            * @param urlTitle the url title
1743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1744            * @return the first matching journal article
1745            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1746            * @throws SystemException if a system exception occurred
1747            */
1748            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
1749                    long groupId, java.lang.String urlTitle,
1750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1751                    throws com.liferay.portal.kernel.exception.SystemException,
1752                            com.liferay.portlet.journal.NoSuchArticleException {
1753                    return getPersistence()
1754                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
1755            }
1756    
1757            /**
1758            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1759            *
1760            * @param groupId the group ID
1761            * @param urlTitle the url title
1762            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1763            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1764            * @throws SystemException if a system exception occurred
1765            */
1766            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
1767                    long groupId, java.lang.String urlTitle,
1768                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1769                    throws com.liferay.portal.kernel.exception.SystemException {
1770                    return getPersistence()
1771                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
1772            }
1773    
1774            /**
1775            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1776            *
1777            * @param groupId the group ID
1778            * @param urlTitle the url title
1779            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1780            * @return the last matching journal article
1781            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1782            * @throws SystemException if a system exception occurred
1783            */
1784            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
1785                    long groupId, java.lang.String urlTitle,
1786                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1787                    throws com.liferay.portal.kernel.exception.SystemException,
1788                            com.liferay.portlet.journal.NoSuchArticleException {
1789                    return getPersistence()
1790                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
1791            }
1792    
1793            /**
1794            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1795            *
1796            * @param groupId the group ID
1797            * @param urlTitle the url title
1798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1799            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1800            * @throws SystemException if a system exception occurred
1801            */
1802            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
1803                    long groupId, java.lang.String urlTitle,
1804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1805                    throws com.liferay.portal.kernel.exception.SystemException {
1806                    return getPersistence()
1807                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
1808            }
1809    
1810            /**
1811            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1812            *
1813            * @param id the primary key of the current journal article
1814            * @param groupId the group ID
1815            * @param urlTitle the url title
1816            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1817            * @return the previous, current, and next journal article
1818            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1819            * @throws SystemException if a system exception occurred
1820            */
1821            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
1822                    long id, long groupId, java.lang.String urlTitle,
1823                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1824                    throws com.liferay.portal.kernel.exception.SystemException,
1825                            com.liferay.portlet.journal.NoSuchArticleException {
1826                    return getPersistence()
1827                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
1828                            orderByComparator);
1829            }
1830    
1831            /**
1832            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1833            *
1834            * @param groupId the group ID
1835            * @param urlTitle the url title
1836            * @return the matching journal articles that the user has permission to view
1837            * @throws SystemException if a system exception occurred
1838            */
1839            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1840                    long groupId, java.lang.String urlTitle)
1841                    throws com.liferay.portal.kernel.exception.SystemException {
1842                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
1843            }
1844    
1845            /**
1846            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1847            *
1848            * <p>
1849            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1850            * </p>
1851            *
1852            * @param groupId the group ID
1853            * @param urlTitle the url title
1854            * @param start the lower bound of the range of journal articles
1855            * @param end the upper bound of the range of journal articles (not inclusive)
1856            * @return the range of matching journal articles that the user has permission to view
1857            * @throws SystemException if a system exception occurred
1858            */
1859            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1860                    long groupId, java.lang.String urlTitle, int start, int end)
1861                    throws com.liferay.portal.kernel.exception.SystemException {
1862                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
1863            }
1864    
1865            /**
1866            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
1867            *
1868            * <p>
1869            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1870            * </p>
1871            *
1872            * @param groupId the group ID
1873            * @param urlTitle the url title
1874            * @param start the lower bound of the range of journal articles
1875            * @param end the upper bound of the range of journal articles (not inclusive)
1876            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1877            * @return the ordered range of matching journal articles that the user has permission to view
1878            * @throws SystemException if a system exception occurred
1879            */
1880            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1881                    long groupId, java.lang.String urlTitle, int start, int end,
1882                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1883                    throws com.liferay.portal.kernel.exception.SystemException {
1884                    return getPersistence()
1885                                       .filterFindByG_UT(groupId, urlTitle, start, end,
1886                            orderByComparator);
1887            }
1888    
1889            /**
1890            * 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;.
1891            *
1892            * @param id the primary key of the current journal article
1893            * @param groupId the group ID
1894            * @param urlTitle the url title
1895            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1896            * @return the previous, current, and next journal article
1897            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1898            * @throws SystemException if a system exception occurred
1899            */
1900            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
1901                    long id, long groupId, java.lang.String urlTitle,
1902                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1903                    throws com.liferay.portal.kernel.exception.SystemException,
1904                            com.liferay.portlet.journal.NoSuchArticleException {
1905                    return getPersistence()
1906                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
1907                            orderByComparator);
1908            }
1909    
1910            /**
1911            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
1912            *
1913            * @param groupId the group ID
1914            * @param structureId the structure ID
1915            * @return the matching journal articles
1916            * @throws SystemException if a system exception occurred
1917            */
1918            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1919                    long groupId, java.lang.String structureId)
1920                    throws com.liferay.portal.kernel.exception.SystemException {
1921                    return getPersistence().findByG_S(groupId, structureId);
1922            }
1923    
1924            /**
1925            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
1926            *
1927            * <p>
1928            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1929            * </p>
1930            *
1931            * @param groupId the group ID
1932            * @param structureId the structure ID
1933            * @param start the lower bound of the range of journal articles
1934            * @param end the upper bound of the range of journal articles (not inclusive)
1935            * @return the range of matching journal articles
1936            * @throws SystemException if a system exception occurred
1937            */
1938            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1939                    long groupId, java.lang.String structureId, int start, int end)
1940                    throws com.liferay.portal.kernel.exception.SystemException {
1941                    return getPersistence().findByG_S(groupId, structureId, start, end);
1942            }
1943    
1944            /**
1945            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
1946            *
1947            * <p>
1948            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1949            * </p>
1950            *
1951            * @param groupId the group ID
1952            * @param structureId the structure ID
1953            * @param start the lower bound of the range of journal articles
1954            * @param end the upper bound of the range of journal articles (not inclusive)
1955            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1956            * @return the ordered range of matching journal articles
1957            * @throws SystemException if a system exception occurred
1958            */
1959            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1960                    long groupId, java.lang.String structureId, int start, int end,
1961                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1962                    throws com.liferay.portal.kernel.exception.SystemException {
1963                    return getPersistence()
1964                                       .findByG_S(groupId, structureId, start, end,
1965                            orderByComparator);
1966            }
1967    
1968            /**
1969            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1970            *
1971            * @param groupId the group ID
1972            * @param structureId the structure ID
1973            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1974            * @return the first matching journal article
1975            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1976            * @throws SystemException if a system exception occurred
1977            */
1978            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
1979                    long groupId, java.lang.String structureId,
1980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1981                    throws com.liferay.portal.kernel.exception.SystemException,
1982                            com.liferay.portlet.journal.NoSuchArticleException {
1983                    return getPersistence()
1984                                       .findByG_S_First(groupId, structureId, orderByComparator);
1985            }
1986    
1987            /**
1988            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1989            *
1990            * @param groupId the group ID
1991            * @param structureId the structure ID
1992            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1993            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1994            * @throws SystemException if a system exception occurred
1995            */
1996            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
1997                    long groupId, java.lang.String structureId,
1998                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1999                    throws com.liferay.portal.kernel.exception.SystemException {
2000                    return getPersistence()
2001                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
2002            }
2003    
2004            /**
2005            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
2006            *
2007            * @param groupId the group ID
2008            * @param structureId the structure ID
2009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2010            * @return the last matching journal article
2011            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2012            * @throws SystemException if a system exception occurred
2013            */
2014            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
2015                    long groupId, java.lang.String structureId,
2016                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2017                    throws com.liferay.portal.kernel.exception.SystemException,
2018                            com.liferay.portlet.journal.NoSuchArticleException {
2019                    return getPersistence()
2020                                       .findByG_S_Last(groupId, structureId, orderByComparator);
2021            }
2022    
2023            /**
2024            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
2025            *
2026            * @param groupId the group ID
2027            * @param structureId the structure ID
2028            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2029            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2030            * @throws SystemException if a system exception occurred
2031            */
2032            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
2033                    long groupId, java.lang.String structureId,
2034                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2035                    throws com.liferay.portal.kernel.exception.SystemException {
2036                    return getPersistence()
2037                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
2038            }
2039    
2040            /**
2041            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
2042            *
2043            * @param id the primary key of the current journal article
2044            * @param groupId the group ID
2045            * @param structureId the structure ID
2046            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2047            * @return the previous, current, and next journal article
2048            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2049            * @throws SystemException if a system exception occurred
2050            */
2051            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
2052                    long id, long groupId, java.lang.String structureId,
2053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2054                    throws com.liferay.portal.kernel.exception.SystemException,
2055                            com.liferay.portlet.journal.NoSuchArticleException {
2056                    return getPersistence()
2057                                       .findByG_S_PrevAndNext(id, groupId, structureId,
2058                            orderByComparator);
2059            }
2060    
2061            /**
2062            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
2063            *
2064            * @param groupId the group ID
2065            * @param structureId the structure ID
2066            * @return the matching journal articles that the user has permission to view
2067            * @throws SystemException if a system exception occurred
2068            */
2069            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
2070                    long groupId, java.lang.String structureId)
2071                    throws com.liferay.portal.kernel.exception.SystemException {
2072                    return getPersistence().filterFindByG_S(groupId, structureId);
2073            }
2074    
2075            /**
2076            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
2077            *
2078            * <p>
2079            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2080            * </p>
2081            *
2082            * @param groupId the group ID
2083            * @param structureId the structure ID
2084            * @param start the lower bound of the range of journal articles
2085            * @param end the upper bound of the range of journal articles (not inclusive)
2086            * @return the range of matching journal articles that the user has permission to view
2087            * @throws SystemException if a system exception occurred
2088            */
2089            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
2090                    long groupId, java.lang.String structureId, int start, int end)
2091                    throws com.liferay.portal.kernel.exception.SystemException {
2092                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
2093            }
2094    
2095            /**
2096            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
2097            *
2098            * <p>
2099            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2100            * </p>
2101            *
2102            * @param groupId the group ID
2103            * @param structureId the structure ID
2104            * @param start the lower bound of the range of journal articles
2105            * @param end the upper bound of the range of journal articles (not inclusive)
2106            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2107            * @return the ordered range of matching journal articles that the user has permission to view
2108            * @throws SystemException if a system exception occurred
2109            */
2110            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
2111                    long groupId, java.lang.String structureId, int start, int end,
2112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2113                    throws com.liferay.portal.kernel.exception.SystemException {
2114                    return getPersistence()
2115                                       .filterFindByG_S(groupId, structureId, start, end,
2116                            orderByComparator);
2117            }
2118    
2119            /**
2120            * 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;.
2121            *
2122            * @param id the primary key of the current journal article
2123            * @param groupId the group ID
2124            * @param structureId the structure ID
2125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2126            * @return the previous, current, and next journal article
2127            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2128            * @throws SystemException if a system exception occurred
2129            */
2130            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
2131                    long id, long groupId, java.lang.String structureId,
2132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2133                    throws com.liferay.portal.kernel.exception.SystemException,
2134                            com.liferay.portlet.journal.NoSuchArticleException {
2135                    return getPersistence()
2136                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
2137                            orderByComparator);
2138            }
2139    
2140            /**
2141            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
2142            *
2143            * @param groupId the group ID
2144            * @param templateId the template ID
2145            * @return the matching journal articles
2146            * @throws SystemException if a system exception occurred
2147            */
2148            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
2149                    long groupId, java.lang.String templateId)
2150                    throws com.liferay.portal.kernel.exception.SystemException {
2151                    return getPersistence().findByG_T(groupId, templateId);
2152            }
2153    
2154            /**
2155            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
2156            *
2157            * <p>
2158            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2159            * </p>
2160            *
2161            * @param groupId the group ID
2162            * @param templateId the template ID
2163            * @param start the lower bound of the range of journal articles
2164            * @param end the upper bound of the range of journal articles (not inclusive)
2165            * @return the range of matching journal articles
2166            * @throws SystemException if a system exception occurred
2167            */
2168            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
2169                    long groupId, java.lang.String templateId, int start, int end)
2170                    throws com.liferay.portal.kernel.exception.SystemException {
2171                    return getPersistence().findByG_T(groupId, templateId, start, end);
2172            }
2173    
2174            /**
2175            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
2176            *
2177            * <p>
2178            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2179            * </p>
2180            *
2181            * @param groupId the group ID
2182            * @param templateId the template ID
2183            * @param start the lower bound of the range of journal articles
2184            * @param end the upper bound of the range of journal articles (not inclusive)
2185            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2186            * @return the ordered range of matching journal articles
2187            * @throws SystemException if a system exception occurred
2188            */
2189            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
2190                    long groupId, java.lang.String templateId, int start, int end,
2191                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2192                    throws com.liferay.portal.kernel.exception.SystemException {
2193                    return getPersistence()
2194                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
2195            }
2196    
2197            /**
2198            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
2199            *
2200            * @param groupId the group ID
2201            * @param templateId the template ID
2202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2203            * @return the first matching journal article
2204            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2205            * @throws SystemException if a system exception occurred
2206            */
2207            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
2208                    long groupId, java.lang.String templateId,
2209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2210                    throws com.liferay.portal.kernel.exception.SystemException,
2211                            com.liferay.portlet.journal.NoSuchArticleException {
2212                    return getPersistence()
2213                                       .findByG_T_First(groupId, templateId, orderByComparator);
2214            }
2215    
2216            /**
2217            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
2218            *
2219            * @param groupId the group ID
2220            * @param templateId the template ID
2221            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2222            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2223            * @throws SystemException if a system exception occurred
2224            */
2225            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
2226                    long groupId, java.lang.String templateId,
2227                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2228                    throws com.liferay.portal.kernel.exception.SystemException {
2229                    return getPersistence()
2230                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
2231            }
2232    
2233            /**
2234            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
2235            *
2236            * @param groupId the group ID
2237            * @param templateId the template ID
2238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2239            * @return the last matching journal article
2240            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2241            * @throws SystemException if a system exception occurred
2242            */
2243            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
2244                    long groupId, java.lang.String templateId,
2245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2246                    throws com.liferay.portal.kernel.exception.SystemException,
2247                            com.liferay.portlet.journal.NoSuchArticleException {
2248                    return getPersistence()
2249                                       .findByG_T_Last(groupId, templateId, orderByComparator);
2250            }
2251    
2252            /**
2253            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
2254            *
2255            * @param groupId the group ID
2256            * @param templateId the template ID
2257            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2258            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2259            * @throws SystemException if a system exception occurred
2260            */
2261            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last(
2262                    long groupId, java.lang.String templateId,
2263                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2264                    throws com.liferay.portal.kernel.exception.SystemException {
2265                    return getPersistence()
2266                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
2267            }
2268    
2269            /**
2270            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
2271            *
2272            * @param id the primary key of the current journal article
2273            * @param groupId the group ID
2274            * @param templateId the template ID
2275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2276            * @return the previous, current, and next journal article
2277            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2278            * @throws SystemException if a system exception occurred
2279            */
2280            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
2281                    long id, long groupId, java.lang.String templateId,
2282                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2283                    throws com.liferay.portal.kernel.exception.SystemException,
2284                            com.liferay.portlet.journal.NoSuchArticleException {
2285                    return getPersistence()
2286                                       .findByG_T_PrevAndNext(id, groupId, templateId,
2287                            orderByComparator);
2288            }
2289    
2290            /**
2291            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
2292            *
2293            * @param groupId the group ID
2294            * @param templateId the template ID
2295            * @return the matching journal articles that the user has permission to view
2296            * @throws SystemException if a system exception occurred
2297            */
2298            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
2299                    long groupId, java.lang.String templateId)
2300                    throws com.liferay.portal.kernel.exception.SystemException {
2301                    return getPersistence().filterFindByG_T(groupId, templateId);
2302            }
2303    
2304            /**
2305            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
2306            *
2307            * <p>
2308            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2309            * </p>
2310            *
2311            * @param groupId the group ID
2312            * @param templateId the template ID
2313            * @param start the lower bound of the range of journal articles
2314            * @param end the upper bound of the range of journal articles (not inclusive)
2315            * @return the range of matching journal articles that the user has permission to view
2316            * @throws SystemException if a system exception occurred
2317            */
2318            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
2319                    long groupId, java.lang.String templateId, int start, int end)
2320                    throws com.liferay.portal.kernel.exception.SystemException {
2321                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
2322            }
2323    
2324            /**
2325            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
2326            *
2327            * <p>
2328            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2329            * </p>
2330            *
2331            * @param groupId the group ID
2332            * @param templateId the template ID
2333            * @param start the lower bound of the range of journal articles
2334            * @param end the upper bound of the range of journal articles (not inclusive)
2335            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2336            * @return the ordered range of matching journal articles that the user has permission to view
2337            * @throws SystemException if a system exception occurred
2338            */
2339            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
2340                    long groupId, java.lang.String templateId, int start, int end,
2341                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2342                    throws com.liferay.portal.kernel.exception.SystemException {
2343                    return getPersistence()
2344                                       .filterFindByG_T(groupId, templateId, start, end,
2345                            orderByComparator);
2346            }
2347    
2348            /**
2349            * 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;.
2350            *
2351            * @param id the primary key of the current journal article
2352            * @param groupId the group ID
2353            * @param templateId the template ID
2354            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2355            * @return the previous, current, and next journal article
2356            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2357            * @throws SystemException if a system exception occurred
2358            */
2359            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
2360                    long id, long groupId, java.lang.String templateId,
2361                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2362                    throws com.liferay.portal.kernel.exception.SystemException,
2363                            com.liferay.portlet.journal.NoSuchArticleException {
2364                    return getPersistence()
2365                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
2366                            orderByComparator);
2367            }
2368    
2369            /**
2370            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2371            *
2372            * @param groupId the group ID
2373            * @param layoutUuid the layout uuid
2374            * @return the matching journal articles
2375            * @throws SystemException if a system exception occurred
2376            */
2377            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
2378                    long groupId, java.lang.String layoutUuid)
2379                    throws com.liferay.portal.kernel.exception.SystemException {
2380                    return getPersistence().findByG_L(groupId, layoutUuid);
2381            }
2382    
2383            /**
2384            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2385            *
2386            * <p>
2387            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2388            * </p>
2389            *
2390            * @param groupId the group ID
2391            * @param layoutUuid the layout uuid
2392            * @param start the lower bound of the range of journal articles
2393            * @param end the upper bound of the range of journal articles (not inclusive)
2394            * @return the range of matching journal articles
2395            * @throws SystemException if a system exception occurred
2396            */
2397            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
2398                    long groupId, java.lang.String layoutUuid, int start, int end)
2399                    throws com.liferay.portal.kernel.exception.SystemException {
2400                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
2401            }
2402    
2403            /**
2404            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2405            *
2406            * <p>
2407            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2408            * </p>
2409            *
2410            * @param groupId the group ID
2411            * @param layoutUuid the layout uuid
2412            * @param start the lower bound of the range of journal articles
2413            * @param end the upper bound of the range of journal articles (not inclusive)
2414            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2415            * @return the ordered range of matching journal articles
2416            * @throws SystemException if a system exception occurred
2417            */
2418            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
2419                    long groupId, java.lang.String layoutUuid, int start, int end,
2420                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2421                    throws com.liferay.portal.kernel.exception.SystemException {
2422                    return getPersistence()
2423                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
2424            }
2425    
2426            /**
2427            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2428            *
2429            * @param groupId the group ID
2430            * @param layoutUuid the layout uuid
2431            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2432            * @return the first matching journal article
2433            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2434            * @throws SystemException if a system exception occurred
2435            */
2436            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
2437                    long groupId, java.lang.String layoutUuid,
2438                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2439                    throws com.liferay.portal.kernel.exception.SystemException,
2440                            com.liferay.portlet.journal.NoSuchArticleException {
2441                    return getPersistence()
2442                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
2443            }
2444    
2445            /**
2446            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2447            *
2448            * @param groupId the group ID
2449            * @param layoutUuid the layout uuid
2450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2451            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2452            * @throws SystemException if a system exception occurred
2453            */
2454            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
2455                    long groupId, java.lang.String layoutUuid,
2456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2457                    throws com.liferay.portal.kernel.exception.SystemException {
2458                    return getPersistence()
2459                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
2460            }
2461    
2462            /**
2463            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2464            *
2465            * @param groupId the group ID
2466            * @param layoutUuid the layout uuid
2467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2468            * @return the last matching journal article
2469            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2470            * @throws SystemException if a system exception occurred
2471            */
2472            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
2473                    long groupId, java.lang.String layoutUuid,
2474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2475                    throws com.liferay.portal.kernel.exception.SystemException,
2476                            com.liferay.portlet.journal.NoSuchArticleException {
2477                    return getPersistence()
2478                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
2479            }
2480    
2481            /**
2482            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2483            *
2484            * @param groupId the group ID
2485            * @param layoutUuid the layout uuid
2486            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2487            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2488            * @throws SystemException if a system exception occurred
2489            */
2490            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
2491                    long groupId, java.lang.String layoutUuid,
2492                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2493                    throws com.liferay.portal.kernel.exception.SystemException {
2494                    return getPersistence()
2495                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
2496            }
2497    
2498            /**
2499            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2500            *
2501            * @param id the primary key of the current journal article
2502            * @param groupId the group ID
2503            * @param layoutUuid the layout uuid
2504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2505            * @return the previous, current, and next journal article
2506            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2507            * @throws SystemException if a system exception occurred
2508            */
2509            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
2510                    long id, long groupId, java.lang.String layoutUuid,
2511                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2512                    throws com.liferay.portal.kernel.exception.SystemException,
2513                            com.liferay.portlet.journal.NoSuchArticleException {
2514                    return getPersistence()
2515                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
2516                            orderByComparator);
2517            }
2518    
2519            /**
2520            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2521            *
2522            * @param groupId the group ID
2523            * @param layoutUuid the layout uuid
2524            * @return the matching journal articles that the user has permission to view
2525            * @throws SystemException if a system exception occurred
2526            */
2527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2528                    long groupId, java.lang.String layoutUuid)
2529                    throws com.liferay.portal.kernel.exception.SystemException {
2530                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
2531            }
2532    
2533            /**
2534            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2535            *
2536            * <p>
2537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2538            * </p>
2539            *
2540            * @param groupId the group ID
2541            * @param layoutUuid the layout uuid
2542            * @param start the lower bound of the range of journal articles
2543            * @param end the upper bound of the range of journal articles (not inclusive)
2544            * @return the range of matching journal articles that the user has permission to view
2545            * @throws SystemException if a system exception occurred
2546            */
2547            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2548                    long groupId, java.lang.String layoutUuid, int start, int end)
2549                    throws com.liferay.portal.kernel.exception.SystemException {
2550                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
2551            }
2552    
2553            /**
2554            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
2555            *
2556            * <p>
2557            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2558            * </p>
2559            *
2560            * @param groupId the group ID
2561            * @param layoutUuid the layout uuid
2562            * @param start the lower bound of the range of journal articles
2563            * @param end the upper bound of the range of journal articles (not inclusive)
2564            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2565            * @return the ordered range of matching journal articles that the user has permission to view
2566            * @throws SystemException if a system exception occurred
2567            */
2568            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2569                    long groupId, java.lang.String layoutUuid, int start, int end,
2570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2571                    throws com.liferay.portal.kernel.exception.SystemException {
2572                    return getPersistence()
2573                                       .filterFindByG_L(groupId, layoutUuid, start, end,
2574                            orderByComparator);
2575            }
2576    
2577            /**
2578            * 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;.
2579            *
2580            * @param id the primary key of the current journal article
2581            * @param groupId the group ID
2582            * @param layoutUuid the layout uuid
2583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2584            * @return the previous, current, and next journal article
2585            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2586            * @throws SystemException if a system exception occurred
2587            */
2588            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
2589                    long id, long groupId, java.lang.String layoutUuid,
2590                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2591                    throws com.liferay.portal.kernel.exception.SystemException,
2592                            com.liferay.portlet.journal.NoSuchArticleException {
2593                    return getPersistence()
2594                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
2595                            orderByComparator);
2596            }
2597    
2598            /**
2599            * Returns all the journal articles where groupId = &#63; and status = &#63;.
2600            *
2601            * @param groupId the group ID
2602            * @param status the status
2603            * @return the matching journal articles
2604            * @throws SystemException if a system exception occurred
2605            */
2606            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2607                    long groupId, int status)
2608                    throws com.liferay.portal.kernel.exception.SystemException {
2609                    return getPersistence().findByG_ST(groupId, status);
2610            }
2611    
2612            /**
2613            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
2614            *
2615            * <p>
2616            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2617            * </p>
2618            *
2619            * @param groupId the group ID
2620            * @param status the status
2621            * @param start the lower bound of the range of journal articles
2622            * @param end the upper bound of the range of journal articles (not inclusive)
2623            * @return the range of matching journal articles
2624            * @throws SystemException if a system exception occurred
2625            */
2626            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2627                    long groupId, int status, int start, int end)
2628                    throws com.liferay.portal.kernel.exception.SystemException {
2629                    return getPersistence().findByG_ST(groupId, status, start, end);
2630            }
2631    
2632            /**
2633            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
2634            *
2635            * <p>
2636            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2637            * </p>
2638            *
2639            * @param groupId the group ID
2640            * @param status the status
2641            * @param start the lower bound of the range of journal articles
2642            * @param end the upper bound of the range of journal articles (not inclusive)
2643            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2644            * @return the ordered range of matching journal articles
2645            * @throws SystemException if a system exception occurred
2646            */
2647            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2648                    long groupId, int status, int start, int end,
2649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2650                    throws com.liferay.portal.kernel.exception.SystemException {
2651                    return getPersistence()
2652                                       .findByG_ST(groupId, status, start, end, orderByComparator);
2653            }
2654    
2655            /**
2656            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
2657            *
2658            * @param groupId the group ID
2659            * @param status the status
2660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2661            * @return the first matching journal article
2662            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2663            * @throws SystemException if a system exception occurred
2664            */
2665            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
2666                    long groupId, int status,
2667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2668                    throws com.liferay.portal.kernel.exception.SystemException,
2669                            com.liferay.portlet.journal.NoSuchArticleException {
2670                    return getPersistence()
2671                                       .findByG_ST_First(groupId, status, orderByComparator);
2672            }
2673    
2674            /**
2675            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
2676            *
2677            * @param groupId the group ID
2678            * @param status the status
2679            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2680            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2681            * @throws SystemException if a system exception occurred
2682            */
2683            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
2684                    long groupId, int status,
2685                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2686                    throws com.liferay.portal.kernel.exception.SystemException {
2687                    return getPersistence()
2688                                       .fetchByG_ST_First(groupId, status, orderByComparator);
2689            }
2690    
2691            /**
2692            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
2693            *
2694            * @param groupId the group ID
2695            * @param status the status
2696            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2697            * @return the last matching journal article
2698            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2699            * @throws SystemException if a system exception occurred
2700            */
2701            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
2702                    long groupId, int status,
2703                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2704                    throws com.liferay.portal.kernel.exception.SystemException,
2705                            com.liferay.portlet.journal.NoSuchArticleException {
2706                    return getPersistence()
2707                                       .findByG_ST_Last(groupId, status, orderByComparator);
2708            }
2709    
2710            /**
2711            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
2712            *
2713            * @param groupId the group ID
2714            * @param status the status
2715            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2716            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2717            * @throws SystemException if a system exception occurred
2718            */
2719            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last(
2720                    long groupId, int status,
2721                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2722                    throws com.liferay.portal.kernel.exception.SystemException {
2723                    return getPersistence()
2724                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
2725            }
2726    
2727            /**
2728            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
2729            *
2730            * @param id the primary key of the current journal article
2731            * @param groupId the group ID
2732            * @param status the status
2733            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2734            * @return the previous, current, and next journal article
2735            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2736            * @throws SystemException if a system exception occurred
2737            */
2738            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
2739                    long id, long groupId, int status,
2740                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2741                    throws com.liferay.portal.kernel.exception.SystemException,
2742                            com.liferay.portlet.journal.NoSuchArticleException {
2743                    return getPersistence()
2744                                       .findByG_ST_PrevAndNext(id, groupId, status,
2745                            orderByComparator);
2746            }
2747    
2748            /**
2749            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2750            *
2751            * @param groupId the group ID
2752            * @param status the status
2753            * @return the matching journal articles that the user has permission to view
2754            * @throws SystemException if a system exception occurred
2755            */
2756            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2757                    long groupId, int status)
2758                    throws com.liferay.portal.kernel.exception.SystemException {
2759                    return getPersistence().filterFindByG_ST(groupId, status);
2760            }
2761    
2762            /**
2763            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2764            *
2765            * <p>
2766            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2767            * </p>
2768            *
2769            * @param groupId the group ID
2770            * @param status the status
2771            * @param start the lower bound of the range of journal articles
2772            * @param end the upper bound of the range of journal articles (not inclusive)
2773            * @return the range of matching journal articles that the user has permission to view
2774            * @throws SystemException if a system exception occurred
2775            */
2776            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2777                    long groupId, int status, int start, int end)
2778                    throws com.liferay.portal.kernel.exception.SystemException {
2779                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
2780            }
2781    
2782            /**
2783            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
2784            *
2785            * <p>
2786            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2787            * </p>
2788            *
2789            * @param groupId the group ID
2790            * @param status the status
2791            * @param start the lower bound of the range of journal articles
2792            * @param end the upper bound of the range of journal articles (not inclusive)
2793            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2794            * @return the ordered range of matching journal articles that the user has permission to view
2795            * @throws SystemException if a system exception occurred
2796            */
2797            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2798                    long groupId, int status, int start, int end,
2799                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2800                    throws com.liferay.portal.kernel.exception.SystemException {
2801                    return getPersistence()
2802                                       .filterFindByG_ST(groupId, status, start, end,
2803                            orderByComparator);
2804            }
2805    
2806            /**
2807            * 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;.
2808            *
2809            * @param id the primary key of the current journal article
2810            * @param groupId the group ID
2811            * @param status the status
2812            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2813            * @return the previous, current, and next journal article
2814            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2815            * @throws SystemException if a system exception occurred
2816            */
2817            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
2818                    long id, long groupId, int status,
2819                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2820                    throws com.liferay.portal.kernel.exception.SystemException,
2821                            com.liferay.portlet.journal.NoSuchArticleException {
2822                    return getPersistence()
2823                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
2824                            orderByComparator);
2825            }
2826    
2827            /**
2828            * Returns all the journal articles where companyId = &#63; and version = &#63;.
2829            *
2830            * @param companyId the company ID
2831            * @param version the version
2832            * @return the matching journal articles
2833            * @throws SystemException if a system exception occurred
2834            */
2835            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2836                    long companyId, double version)
2837                    throws com.liferay.portal.kernel.exception.SystemException {
2838                    return getPersistence().findByC_V(companyId, version);
2839            }
2840    
2841            /**
2842            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
2843            *
2844            * <p>
2845            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2846            * </p>
2847            *
2848            * @param companyId the company ID
2849            * @param version the version
2850            * @param start the lower bound of the range of journal articles
2851            * @param end the upper bound of the range of journal articles (not inclusive)
2852            * @return the range of matching journal articles
2853            * @throws SystemException if a system exception occurred
2854            */
2855            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2856                    long companyId, double version, int start, int end)
2857                    throws com.liferay.portal.kernel.exception.SystemException {
2858                    return getPersistence().findByC_V(companyId, version, start, end);
2859            }
2860    
2861            /**
2862            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
2863            *
2864            * <p>
2865            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2866            * </p>
2867            *
2868            * @param companyId the company ID
2869            * @param version the version
2870            * @param start the lower bound of the range of journal articles
2871            * @param end the upper bound of the range of journal articles (not inclusive)
2872            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2873            * @return the ordered range of matching journal articles
2874            * @throws SystemException if a system exception occurred
2875            */
2876            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2877                    long companyId, double version, int start, int end,
2878                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2879                    throws com.liferay.portal.kernel.exception.SystemException {
2880                    return getPersistence()
2881                                       .findByC_V(companyId, version, start, end, orderByComparator);
2882            }
2883    
2884            /**
2885            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
2886            *
2887            * @param companyId the company ID
2888            * @param version the version
2889            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2890            * @return the first matching journal article
2891            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2892            * @throws SystemException if a system exception occurred
2893            */
2894            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
2895                    long companyId, double version,
2896                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2897                    throws com.liferay.portal.kernel.exception.SystemException,
2898                            com.liferay.portlet.journal.NoSuchArticleException {
2899                    return getPersistence()
2900                                       .findByC_V_First(companyId, version, orderByComparator);
2901            }
2902    
2903            /**
2904            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
2905            *
2906            * @param companyId the company ID
2907            * @param version the version
2908            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2909            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2910            * @throws SystemException if a system exception occurred
2911            */
2912            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
2913                    long companyId, double version,
2914                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2915                    throws com.liferay.portal.kernel.exception.SystemException {
2916                    return getPersistence()
2917                                       .fetchByC_V_First(companyId, version, orderByComparator);
2918            }
2919    
2920            /**
2921            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
2922            *
2923            * @param companyId the company ID
2924            * @param version the version
2925            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2926            * @return the last matching journal article
2927            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2928            * @throws SystemException if a system exception occurred
2929            */
2930            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
2931                    long companyId, double version,
2932                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2933                    throws com.liferay.portal.kernel.exception.SystemException,
2934                            com.liferay.portlet.journal.NoSuchArticleException {
2935                    return getPersistence()
2936                                       .findByC_V_Last(companyId, version, orderByComparator);
2937            }
2938    
2939            /**
2940            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
2941            *
2942            * @param companyId the company ID
2943            * @param version the version
2944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2945            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2946            * @throws SystemException if a system exception occurred
2947            */
2948            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
2949                    long companyId, double version,
2950                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2951                    throws com.liferay.portal.kernel.exception.SystemException {
2952                    return getPersistence()
2953                                       .fetchByC_V_Last(companyId, version, orderByComparator);
2954            }
2955    
2956            /**
2957            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
2958            *
2959            * @param id the primary key of the current journal article
2960            * @param companyId the company ID
2961            * @param version the version
2962            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2963            * @return the previous, current, and next journal article
2964            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2965            * @throws SystemException if a system exception occurred
2966            */
2967            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
2968                    long id, long companyId, double version,
2969                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2970                    throws com.liferay.portal.kernel.exception.SystemException,
2971                            com.liferay.portlet.journal.NoSuchArticleException {
2972                    return getPersistence()
2973                                       .findByC_V_PrevAndNext(id, companyId, version,
2974                            orderByComparator);
2975            }
2976    
2977            /**
2978            * Returns all the journal articles where companyId = &#63; and status = &#63;.
2979            *
2980            * @param companyId the company ID
2981            * @param status the status
2982            * @return the matching journal articles
2983            * @throws SystemException if a system exception occurred
2984            */
2985            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2986                    long companyId, int status)
2987                    throws com.liferay.portal.kernel.exception.SystemException {
2988                    return getPersistence().findByC_ST(companyId, status);
2989            }
2990    
2991            /**
2992            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
2993            *
2994            * <p>
2995            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2996            * </p>
2997            *
2998            * @param companyId the company ID
2999            * @param status the status
3000            * @param start the lower bound of the range of journal articles
3001            * @param end the upper bound of the range of journal articles (not inclusive)
3002            * @return the range of matching journal articles
3003            * @throws SystemException if a system exception occurred
3004            */
3005            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
3006                    long companyId, int status, int start, int end)
3007                    throws com.liferay.portal.kernel.exception.SystemException {
3008                    return getPersistence().findByC_ST(companyId, status, start, end);
3009            }
3010    
3011            /**
3012            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
3013            *
3014            * <p>
3015            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3016            * </p>
3017            *
3018            * @param companyId the company ID
3019            * @param status the status
3020            * @param start the lower bound of the range of journal articles
3021            * @param end the upper bound of the range of journal articles (not inclusive)
3022            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3023            * @return the ordered range of matching journal articles
3024            * @throws SystemException if a system exception occurred
3025            */
3026            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
3027                    long companyId, int status, int start, int end,
3028                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3029                    throws com.liferay.portal.kernel.exception.SystemException {
3030                    return getPersistence()
3031                                       .findByC_ST(companyId, status, start, end, orderByComparator);
3032            }
3033    
3034            /**
3035            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
3036            *
3037            * @param companyId the company ID
3038            * @param status the status
3039            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3040            * @return the first matching journal article
3041            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3042            * @throws SystemException if a system exception occurred
3043            */
3044            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
3045                    long companyId, int status,
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                                       .findByC_ST_First(companyId, status, orderByComparator);
3051            }
3052    
3053            /**
3054            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
3055            *
3056            * @param companyId the company ID
3057            * @param status the status
3058            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3059            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3060            * @throws SystemException if a system exception occurred
3061            */
3062            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
3063                    long companyId, int status,
3064                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3065                    throws com.liferay.portal.kernel.exception.SystemException {
3066                    return getPersistence()
3067                                       .fetchByC_ST_First(companyId, status, orderByComparator);
3068            }
3069    
3070            /**
3071            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
3072            *
3073            * @param companyId the company ID
3074            * @param status the status
3075            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3076            * @return the last matching journal article
3077            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3078            * @throws SystemException if a system exception occurred
3079            */
3080            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
3081                    long companyId, int status,
3082                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3083                    throws com.liferay.portal.kernel.exception.SystemException,
3084                            com.liferay.portlet.journal.NoSuchArticleException {
3085                    return getPersistence()
3086                                       .findByC_ST_Last(companyId, status, orderByComparator);
3087            }
3088    
3089            /**
3090            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
3091            *
3092            * @param companyId the company ID
3093            * @param status the status
3094            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3095            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3096            * @throws SystemException if a system exception occurred
3097            */
3098            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
3099                    long companyId, int status,
3100                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3101                    throws com.liferay.portal.kernel.exception.SystemException {
3102                    return getPersistence()
3103                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
3104            }
3105    
3106            /**
3107            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
3108            *
3109            * @param id the primary key of the current journal article
3110            * @param companyId the company ID
3111            * @param status the status
3112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3113            * @return the previous, current, and next journal article
3114            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3115            * @throws SystemException if a system exception occurred
3116            */
3117            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
3118                    long id, long companyId, int status,
3119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3120                    throws com.liferay.portal.kernel.exception.SystemException,
3121                            com.liferay.portlet.journal.NoSuchArticleException {
3122                    return getPersistence()
3123                                       .findByC_ST_PrevAndNext(id, companyId, status,
3124                            orderByComparator);
3125            }
3126    
3127            /**
3128            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3129            *
3130            * @param groupId the group ID
3131            * @param classNameId the class name ID
3132            * @param classPK the class p k
3133            * @return the matching journal articles
3134            * @throws SystemException if a system exception occurred
3135            */
3136            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
3137                    long groupId, long classNameId, long classPK)
3138                    throws com.liferay.portal.kernel.exception.SystemException {
3139                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
3140            }
3141    
3142            /**
3143            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#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 classPK the class p k
3152            * @param start the lower bound of the range of journal articles
3153            * @param end the upper bound of the range of journal articles (not inclusive)
3154            * @return the range of matching journal articles
3155            * @throws SystemException if a system exception occurred
3156            */
3157            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
3158                    long groupId, long classNameId, long classPK, int start, int end)
3159                    throws com.liferay.portal.kernel.exception.SystemException {
3160                    return getPersistence()
3161                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
3162            }
3163    
3164            /**
3165            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3166            *
3167            * <p>
3168            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3169            * </p>
3170            *
3171            * @param groupId the group ID
3172            * @param classNameId the class name ID
3173            * @param classPK the class p k
3174            * @param start the lower bound of the range of journal articles
3175            * @param end the upper bound of the range of journal articles (not inclusive)
3176            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3177            * @return the ordered range of matching journal articles
3178            * @throws SystemException if a system exception occurred
3179            */
3180            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
3181                    long groupId, long classNameId, long classPK, int start, int end,
3182                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3183                    throws com.liferay.portal.kernel.exception.SystemException {
3184                    return getPersistence()
3185                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
3186                            orderByComparator);
3187            }
3188    
3189            /**
3190            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3191            *
3192            * @param groupId the group ID
3193            * @param classNameId the class name ID
3194            * @param classPK the class p k
3195            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3196            * @return the first matching journal article
3197            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3198            * @throws SystemException if a system exception occurred
3199            */
3200            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
3201                    long groupId, long classNameId, long classPK,
3202                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3203                    throws com.liferay.portal.kernel.exception.SystemException,
3204                            com.liferay.portlet.journal.NoSuchArticleException {
3205                    return getPersistence()
3206                                       .findByG_C_C_First(groupId, classNameId, classPK,
3207                            orderByComparator);
3208            }
3209    
3210            /**
3211            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3212            *
3213            * @param groupId the group ID
3214            * @param classNameId the class name ID
3215            * @param classPK the class p k
3216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3217            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3218            * @throws SystemException if a system exception occurred
3219            */
3220            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
3221                    long groupId, long classNameId, long classPK,
3222                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3223                    throws com.liferay.portal.kernel.exception.SystemException {
3224                    return getPersistence()
3225                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
3226                            orderByComparator);
3227            }
3228    
3229            /**
3230            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3231            *
3232            * @param groupId the group ID
3233            * @param classNameId the class name ID
3234            * @param classPK the class p k
3235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3236            * @return the last matching journal article
3237            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3238            * @throws SystemException if a system exception occurred
3239            */
3240            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
3241                    long groupId, long classNameId, long classPK,
3242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3243                    throws com.liferay.portal.kernel.exception.SystemException,
3244                            com.liferay.portlet.journal.NoSuchArticleException {
3245                    return getPersistence()
3246                                       .findByG_C_C_Last(groupId, classNameId, classPK,
3247                            orderByComparator);
3248            }
3249    
3250            /**
3251            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3252            *
3253            * @param groupId the group ID
3254            * @param classNameId the class name ID
3255            * @param classPK the class p k
3256            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3257            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3258            * @throws SystemException if a system exception occurred
3259            */
3260            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
3261                    long groupId, long classNameId, long classPK,
3262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3263                    throws com.liferay.portal.kernel.exception.SystemException {
3264                    return getPersistence()
3265                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
3266                            orderByComparator);
3267            }
3268    
3269            /**
3270            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3271            *
3272            * @param id the primary key of the current journal article
3273            * @param groupId the group ID
3274            * @param classNameId the class name ID
3275            * @param classPK the class p k
3276            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3277            * @return the previous, current, and next journal article
3278            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3279            * @throws SystemException if a system exception occurred
3280            */
3281            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
3282                    long id, long groupId, long classNameId, long classPK,
3283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3284                    throws com.liferay.portal.kernel.exception.SystemException,
3285                            com.liferay.portlet.journal.NoSuchArticleException {
3286                    return getPersistence()
3287                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
3288                            orderByComparator);
3289            }
3290    
3291            /**
3292            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3293            *
3294            * @param groupId the group ID
3295            * @param classNameId the class name ID
3296            * @param classPK the class p k
3297            * @return the matching journal articles that the user has permission to view
3298            * @throws SystemException if a system exception occurred
3299            */
3300            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
3301                    long groupId, long classNameId, long classPK)
3302                    throws com.liferay.portal.kernel.exception.SystemException {
3303                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
3304            }
3305    
3306            /**
3307            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
3308            *
3309            * <p>
3310            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3311            * </p>
3312            *
3313            * @param groupId the group ID
3314            * @param classNameId the class name ID
3315            * @param classPK the class p k
3316            * @param start the lower bound of the range of journal articles
3317            * @param end the upper bound of the range of journal articles (not inclusive)
3318            * @return the range of matching journal articles that the user has permission to view
3319            * @throws SystemException if a system exception occurred
3320            */
3321            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
3322                    long groupId, long classNameId, long classPK, int start, int end)
3323                    throws com.liferay.portal.kernel.exception.SystemException {
3324                    return getPersistence()
3325                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
3326            }
3327    
3328            /**
3329            * 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;.
3330            *
3331            * <p>
3332            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3333            * </p>
3334            *
3335            * @param groupId the group ID
3336            * @param classNameId the class name ID
3337            * @param classPK the class p k
3338            * @param start the lower bound of the range of journal articles
3339            * @param end the upper bound of the range of journal articles (not inclusive)
3340            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3341            * @return the ordered range of matching journal articles that the user has permission to view
3342            * @throws SystemException if a system exception occurred
3343            */
3344            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
3345                    long groupId, long classNameId, long classPK, int start, int end,
3346                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3347                    throws com.liferay.portal.kernel.exception.SystemException {
3348                    return getPersistence()
3349                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
3350                            end, orderByComparator);
3351            }
3352    
3353            /**
3354            * 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;.
3355            *
3356            * @param id the primary key of the current journal article
3357            * @param groupId the group ID
3358            * @param classNameId the class name ID
3359            * @param classPK the class p k
3360            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3361            * @return the previous, current, and next journal article
3362            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3363            * @throws SystemException if a system exception occurred
3364            */
3365            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
3366                    long id, long groupId, long classNameId, long classPK,
3367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3368                    throws com.liferay.portal.kernel.exception.SystemException,
3369                            com.liferay.portlet.journal.NoSuchArticleException {
3370                    return getPersistence()
3371                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
3372                            classPK, orderByComparator);
3373            }
3374    
3375            /**
3376            * 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.
3377            *
3378            * @param groupId the group ID
3379            * @param classNameId the class name ID
3380            * @param structureId the structure ID
3381            * @return the matching journal article
3382            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3383            * @throws SystemException if a system exception occurred
3384            */
3385            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
3386                    long groupId, long classNameId, java.lang.String structureId)
3387                    throws com.liferay.portal.kernel.exception.SystemException,
3388                            com.liferay.portlet.journal.NoSuchArticleException {
3389                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
3390            }
3391    
3392            /**
3393            * 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.
3394            *
3395            * @param groupId the group ID
3396            * @param classNameId the class name ID
3397            * @param structureId the structure ID
3398            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3399            * @throws SystemException if a system exception occurred
3400            */
3401            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
3402                    long groupId, long classNameId, java.lang.String structureId)
3403                    throws com.liferay.portal.kernel.exception.SystemException {
3404                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
3405            }
3406    
3407            /**
3408            * 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.
3409            *
3410            * @param groupId the group ID
3411            * @param classNameId the class name ID
3412            * @param structureId the structure ID
3413            * @param retrieveFromCache whether to use the finder cache
3414            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3415            * @throws SystemException if a system exception occurred
3416            */
3417            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
3418                    long groupId, long classNameId, java.lang.String structureId,
3419                    boolean retrieveFromCache)
3420                    throws com.liferay.portal.kernel.exception.SystemException {
3421                    return getPersistence()
3422                                       .fetchByG_C_S(groupId, classNameId, structureId,
3423                            retrieveFromCache);
3424            }
3425    
3426            /**
3427            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3428            *
3429            * @param groupId the group ID
3430            * @param classNameId the class name ID
3431            * @param templateId the template ID
3432            * @return the matching journal articles
3433            * @throws SystemException if a system exception occurred
3434            */
3435            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
3436                    long groupId, long classNameId, java.lang.String templateId)
3437                    throws com.liferay.portal.kernel.exception.SystemException {
3438                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
3439            }
3440    
3441            /**
3442            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3443            *
3444            * <p>
3445            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3446            * </p>
3447            *
3448            * @param groupId the group ID
3449            * @param classNameId the class name ID
3450            * @param templateId the template ID
3451            * @param start the lower bound of the range of journal articles
3452            * @param end the upper bound of the range of journal articles (not inclusive)
3453            * @return the range of matching journal articles
3454            * @throws SystemException if a system exception occurred
3455            */
3456            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
3457                    long groupId, long classNameId, java.lang.String templateId, int start,
3458                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3459                    return getPersistence()
3460                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
3461            }
3462    
3463            /**
3464            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3465            *
3466            * <p>
3467            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3468            * </p>
3469            *
3470            * @param groupId the group ID
3471            * @param classNameId the class name ID
3472            * @param templateId the template ID
3473            * @param start the lower bound of the range of journal articles
3474            * @param end the upper bound of the range of journal articles (not inclusive)
3475            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3476            * @return the ordered range of matching journal articles
3477            * @throws SystemException if a system exception occurred
3478            */
3479            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
3480                    long groupId, long classNameId, java.lang.String templateId, int start,
3481                    int end,
3482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3483                    throws com.liferay.portal.kernel.exception.SystemException {
3484                    return getPersistence()
3485                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
3486                            orderByComparator);
3487            }
3488    
3489            /**
3490            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3491            *
3492            * @param groupId the group ID
3493            * @param classNameId the class name ID
3494            * @param templateId the template ID
3495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3496            * @return the first matching journal article
3497            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3498            * @throws SystemException if a system exception occurred
3499            */
3500            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
3501                    long groupId, long classNameId, java.lang.String templateId,
3502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3503                    throws com.liferay.portal.kernel.exception.SystemException,
3504                            com.liferay.portlet.journal.NoSuchArticleException {
3505                    return getPersistence()
3506                                       .findByG_C_T_First(groupId, classNameId, templateId,
3507                            orderByComparator);
3508            }
3509    
3510            /**
3511            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3512            *
3513            * @param groupId the group ID
3514            * @param classNameId the class name ID
3515            * @param templateId the template ID
3516            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3517            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3518            * @throws SystemException if a system exception occurred
3519            */
3520            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
3521                    long groupId, long classNameId, java.lang.String templateId,
3522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3523                    throws com.liferay.portal.kernel.exception.SystemException {
3524                    return getPersistence()
3525                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
3526                            orderByComparator);
3527            }
3528    
3529            /**
3530            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3531            *
3532            * @param groupId the group ID
3533            * @param classNameId the class name ID
3534            * @param templateId the template ID
3535            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3536            * @return the last matching journal article
3537            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3538            * @throws SystemException if a system exception occurred
3539            */
3540            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
3541                    long groupId, long classNameId, java.lang.String templateId,
3542                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3543                    throws com.liferay.portal.kernel.exception.SystemException,
3544                            com.liferay.portlet.journal.NoSuchArticleException {
3545                    return getPersistence()
3546                                       .findByG_C_T_Last(groupId, classNameId, templateId,
3547                            orderByComparator);
3548            }
3549    
3550            /**
3551            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3552            *
3553            * @param groupId the group ID
3554            * @param classNameId the class name ID
3555            * @param templateId the template ID
3556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3557            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3558            * @throws SystemException if a system exception occurred
3559            */
3560            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
3561                    long groupId, long classNameId, java.lang.String templateId,
3562                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3563                    throws com.liferay.portal.kernel.exception.SystemException {
3564                    return getPersistence()
3565                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
3566                            orderByComparator);
3567            }
3568    
3569            /**
3570            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3571            *
3572            * @param id the primary key of the current journal article
3573            * @param groupId the group ID
3574            * @param classNameId the class name ID
3575            * @param templateId the template ID
3576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3577            * @return the previous, current, and next journal article
3578            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3579            * @throws SystemException if a system exception occurred
3580            */
3581            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
3582                    long id, long groupId, long classNameId, java.lang.String templateId,
3583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3584                    throws com.liferay.portal.kernel.exception.SystemException,
3585                            com.liferay.portlet.journal.NoSuchArticleException {
3586                    return getPersistence()
3587                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
3588                            templateId, orderByComparator);
3589            }
3590    
3591            /**
3592            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3593            *
3594            * @param groupId the group ID
3595            * @param classNameId the class name ID
3596            * @param templateId the template ID
3597            * @return the matching journal articles that the user has permission to view
3598            * @throws SystemException if a system exception occurred
3599            */
3600            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3601                    long groupId, long classNameId, java.lang.String templateId)
3602                    throws com.liferay.portal.kernel.exception.SystemException {
3603                    return getPersistence()
3604                                       .filterFindByG_C_T(groupId, classNameId, templateId);
3605            }
3606    
3607            /**
3608            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3609            *
3610            * <p>
3611            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3612            * </p>
3613            *
3614            * @param groupId the group ID
3615            * @param classNameId the class name ID
3616            * @param templateId the template ID
3617            * @param start the lower bound of the range of journal articles
3618            * @param end the upper bound of the range of journal articles (not inclusive)
3619            * @return the range of matching journal articles that the user has permission to view
3620            * @throws SystemException if a system exception occurred
3621            */
3622            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3623                    long groupId, long classNameId, java.lang.String templateId, int start,
3624                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3625                    return getPersistence()
3626                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3627                            end);
3628            }
3629    
3630            /**
3631            * 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;.
3632            *
3633            * <p>
3634            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3635            * </p>
3636            *
3637            * @param groupId the group ID
3638            * @param classNameId the class name ID
3639            * @param templateId the template ID
3640            * @param start the lower bound of the range of journal articles
3641            * @param end the upper bound of the range of journal articles (not inclusive)
3642            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3643            * @return the ordered range of matching journal articles that the user has permission to view
3644            * @throws SystemException if a system exception occurred
3645            */
3646            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3647                    long groupId, long classNameId, java.lang.String templateId, int start,
3648                    int end,
3649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3650                    throws com.liferay.portal.kernel.exception.SystemException {
3651                    return getPersistence()
3652                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3653                            end, orderByComparator);
3654            }
3655    
3656            /**
3657            * 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;.
3658            *
3659            * @param id the primary key of the current journal article
3660            * @param groupId the group ID
3661            * @param classNameId the class name ID
3662            * @param templateId the template ID
3663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3664            * @return the previous, current, and next journal article
3665            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3666            * @throws SystemException if a system exception occurred
3667            */
3668            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
3669                    long id, long groupId, long classNameId, java.lang.String templateId,
3670                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3671                    throws com.liferay.portal.kernel.exception.SystemException,
3672                            com.liferay.portlet.journal.NoSuchArticleException {
3673                    return getPersistence()
3674                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
3675                            templateId, orderByComparator);
3676            }
3677    
3678            /**
3679            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3680            *
3681            * @param groupId the group ID
3682            * @param classNameId the class name ID
3683            * @param layoutUuid the layout uuid
3684            * @return the matching journal articles
3685            * @throws SystemException if a system exception occurred
3686            */
3687            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3688                    long groupId, long classNameId, java.lang.String layoutUuid)
3689                    throws com.liferay.portal.kernel.exception.SystemException {
3690                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
3691            }
3692    
3693            /**
3694            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3695            *
3696            * <p>
3697            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3698            * </p>
3699            *
3700            * @param groupId the group ID
3701            * @param classNameId the class name ID
3702            * @param layoutUuid the layout uuid
3703            * @param start the lower bound of the range of journal articles
3704            * @param end the upper bound of the range of journal articles (not inclusive)
3705            * @return the range of matching journal articles
3706            * @throws SystemException if a system exception occurred
3707            */
3708            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3709                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3710                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3711                    return getPersistence()
3712                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
3713            }
3714    
3715            /**
3716            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3717            *
3718            * <p>
3719            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3720            * </p>
3721            *
3722            * @param groupId the group ID
3723            * @param classNameId the class name ID
3724            * @param layoutUuid the layout uuid
3725            * @param start the lower bound of the range of journal articles
3726            * @param end the upper bound of the range of journal articles (not inclusive)
3727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3728            * @return the ordered range of matching journal articles
3729            * @throws SystemException if a system exception occurred
3730            */
3731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3732                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3733                    int end,
3734                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3735                    throws com.liferay.portal.kernel.exception.SystemException {
3736                    return getPersistence()
3737                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
3738                            orderByComparator);
3739            }
3740    
3741            /**
3742            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3743            *
3744            * @param groupId the group ID
3745            * @param classNameId the class name ID
3746            * @param layoutUuid the layout uuid
3747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3748            * @return the first matching journal article
3749            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3750            * @throws SystemException if a system exception occurred
3751            */
3752            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
3753                    long groupId, long classNameId, java.lang.String layoutUuid,
3754                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3755                    throws com.liferay.portal.kernel.exception.SystemException,
3756                            com.liferay.portlet.journal.NoSuchArticleException {
3757                    return getPersistence()
3758                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
3759                            orderByComparator);
3760            }
3761    
3762            /**
3763            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3764            *
3765            * @param groupId the group ID
3766            * @param classNameId the class name ID
3767            * @param layoutUuid the layout uuid
3768            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3769            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3770            * @throws SystemException if a system exception occurred
3771            */
3772            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
3773                    long groupId, long classNameId, java.lang.String layoutUuid,
3774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3775                    throws com.liferay.portal.kernel.exception.SystemException {
3776                    return getPersistence()
3777                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
3778                            orderByComparator);
3779            }
3780    
3781            /**
3782            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3783            *
3784            * @param groupId the group ID
3785            * @param classNameId the class name ID
3786            * @param layoutUuid the layout uuid
3787            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3788            * @return the last matching journal article
3789            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3790            * @throws SystemException if a system exception occurred
3791            */
3792            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
3793                    long groupId, long classNameId, java.lang.String layoutUuid,
3794                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3795                    throws com.liferay.portal.kernel.exception.SystemException,
3796                            com.liferay.portlet.journal.NoSuchArticleException {
3797                    return getPersistence()
3798                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
3799                            orderByComparator);
3800            }
3801    
3802            /**
3803            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3804            *
3805            * @param groupId the group ID
3806            * @param classNameId the class name ID
3807            * @param layoutUuid the layout uuid
3808            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3809            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3810            * @throws SystemException if a system exception occurred
3811            */
3812            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
3813                    long groupId, long classNameId, java.lang.String layoutUuid,
3814                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3815                    throws com.liferay.portal.kernel.exception.SystemException {
3816                    return getPersistence()
3817                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
3818                            orderByComparator);
3819            }
3820    
3821            /**
3822            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3823            *
3824            * @param id the primary key of the current journal article
3825            * @param groupId the group ID
3826            * @param classNameId the class name ID
3827            * @param layoutUuid the layout uuid
3828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3829            * @return the previous, current, and next journal article
3830            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3831            * @throws SystemException if a system exception occurred
3832            */
3833            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
3834                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3835                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3836                    throws com.liferay.portal.kernel.exception.SystemException,
3837                            com.liferay.portlet.journal.NoSuchArticleException {
3838                    return getPersistence()
3839                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
3840                            layoutUuid, orderByComparator);
3841            }
3842    
3843            /**
3844            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3845            *
3846            * @param groupId the group ID
3847            * @param classNameId the class name ID
3848            * @param layoutUuid the layout uuid
3849            * @return the matching journal articles that the user has permission to view
3850            * @throws SystemException if a system exception occurred
3851            */
3852            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3853                    long groupId, long classNameId, java.lang.String layoutUuid)
3854                    throws com.liferay.portal.kernel.exception.SystemException {
3855                    return getPersistence()
3856                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
3857            }
3858    
3859            /**
3860            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3861            *
3862            * <p>
3863            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3864            * </p>
3865            *
3866            * @param groupId the group ID
3867            * @param classNameId the class name ID
3868            * @param layoutUuid the layout uuid
3869            * @param start the lower bound of the range of journal articles
3870            * @param end the upper bound of the range of journal articles (not inclusive)
3871            * @return the range of matching journal articles that the user has permission to view
3872            * @throws SystemException if a system exception occurred
3873            */
3874            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3875                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3876                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3877                    return getPersistence()
3878                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3879                            end);
3880            }
3881    
3882            /**
3883            * 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;.
3884            *
3885            * <p>
3886            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3887            * </p>
3888            *
3889            * @param groupId the group ID
3890            * @param classNameId the class name ID
3891            * @param layoutUuid the layout uuid
3892            * @param start the lower bound of the range of journal articles
3893            * @param end the upper bound of the range of journal articles (not inclusive)
3894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3895            * @return the ordered range of matching journal articles that the user has permission to view
3896            * @throws SystemException if a system exception occurred
3897            */
3898            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3899                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3900                    int end,
3901                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3902                    throws com.liferay.portal.kernel.exception.SystemException {
3903                    return getPersistence()
3904                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3905                            end, orderByComparator);
3906            }
3907    
3908            /**
3909            * 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;.
3910            *
3911            * @param id the primary key of the current journal article
3912            * @param groupId the group ID
3913            * @param classNameId the class name ID
3914            * @param layoutUuid the layout uuid
3915            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3916            * @return the previous, current, and next journal article
3917            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3918            * @throws SystemException if a system exception occurred
3919            */
3920            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
3921                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3922                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3923                    throws com.liferay.portal.kernel.exception.SystemException,
3924                            com.liferay.portlet.journal.NoSuchArticleException {
3925                    return getPersistence()
3926                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
3927                            layoutUuid, orderByComparator);
3928            }
3929    
3930            /**
3931            * 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.
3932            *
3933            * @param groupId the group ID
3934            * @param articleId the article ID
3935            * @param version the version
3936            * @return the matching journal article
3937            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3938            * @throws SystemException if a system exception occurred
3939            */
3940            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
3941                    long groupId, java.lang.String articleId, double version)
3942                    throws com.liferay.portal.kernel.exception.SystemException,
3943                            com.liferay.portlet.journal.NoSuchArticleException {
3944                    return getPersistence().findByG_A_V(groupId, articleId, version);
3945            }
3946    
3947            /**
3948            * 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.
3949            *
3950            * @param groupId the group ID
3951            * @param articleId the article ID
3952            * @param version the version
3953            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3954            * @throws SystemException if a system exception occurred
3955            */
3956            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3957                    long groupId, java.lang.String articleId, double version)
3958                    throws com.liferay.portal.kernel.exception.SystemException {
3959                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
3960            }
3961    
3962            /**
3963            * 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.
3964            *
3965            * @param groupId the group ID
3966            * @param articleId the article ID
3967            * @param version the version
3968            * @param retrieveFromCache whether to use the finder cache
3969            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3970            * @throws SystemException if a system exception occurred
3971            */
3972            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3973                    long groupId, java.lang.String articleId, double version,
3974                    boolean retrieveFromCache)
3975                    throws com.liferay.portal.kernel.exception.SystemException {
3976                    return getPersistence()
3977                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
3978            }
3979    
3980            /**
3981            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3982            *
3983            * @param groupId the group ID
3984            * @param articleId the article ID
3985            * @param status the status
3986            * @return the matching journal articles
3987            * @throws SystemException if a system exception occurred
3988            */
3989            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3990                    long groupId, java.lang.String articleId, int status)
3991                    throws com.liferay.portal.kernel.exception.SystemException {
3992                    return getPersistence().findByG_A_ST(groupId, articleId, status);
3993            }
3994    
3995            /**
3996            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3997            *
3998            * <p>
3999            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4000            * </p>
4001            *
4002            * @param groupId the group ID
4003            * @param articleId the article ID
4004            * @param status the status
4005            * @param start the lower bound of the range of journal articles
4006            * @param end the upper bound of the range of journal articles (not inclusive)
4007            * @return the range of matching journal articles
4008            * @throws SystemException if a system exception occurred
4009            */
4010            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
4011                    long groupId, java.lang.String articleId, int status, int start, int end)
4012                    throws com.liferay.portal.kernel.exception.SystemException {
4013                    return getPersistence()
4014                                       .findByG_A_ST(groupId, articleId, status, start, end);
4015            }
4016    
4017            /**
4018            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
4019            *
4020            * <p>
4021            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4022            * </p>
4023            *
4024            * @param groupId the group ID
4025            * @param articleId the article ID
4026            * @param status the status
4027            * @param start the lower bound of the range of journal articles
4028            * @param end the upper bound of the range of journal articles (not inclusive)
4029            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4030            * @return the ordered range of matching journal articles
4031            * @throws SystemException if a system exception occurred
4032            */
4033            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
4034                    long groupId, java.lang.String articleId, int status, int start,
4035                    int end,
4036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4037                    throws com.liferay.portal.kernel.exception.SystemException {
4038                    return getPersistence()
4039                                       .findByG_A_ST(groupId, articleId, status, start, end,
4040                            orderByComparator);
4041            }
4042    
4043            /**
4044            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
4045            *
4046            * @param groupId the group ID
4047            * @param articleId the article ID
4048            * @param status the status
4049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4050            * @return the first matching journal article
4051            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4052            * @throws SystemException if a system exception occurred
4053            */
4054            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
4055                    long groupId, java.lang.String articleId, int status,
4056                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4057                    throws com.liferay.portal.kernel.exception.SystemException,
4058                            com.liferay.portlet.journal.NoSuchArticleException {
4059                    return getPersistence()
4060                                       .findByG_A_ST_First(groupId, articleId, status,
4061                            orderByComparator);
4062            }
4063    
4064            /**
4065            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
4066            *
4067            * @param groupId the group ID
4068            * @param articleId the article ID
4069            * @param status the status
4070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4071            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4072            * @throws SystemException if a system exception occurred
4073            */
4074            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
4075                    long groupId, java.lang.String articleId, int status,
4076                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4077                    throws com.liferay.portal.kernel.exception.SystemException {
4078                    return getPersistence()
4079                                       .fetchByG_A_ST_First(groupId, articleId, status,
4080                            orderByComparator);
4081            }
4082    
4083            /**
4084            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
4085            *
4086            * @param groupId the group ID
4087            * @param articleId the article ID
4088            * @param status the status
4089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4090            * @return the last matching journal article
4091            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4092            * @throws SystemException if a system exception occurred
4093            */
4094            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
4095                    long groupId, java.lang.String articleId, int status,
4096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4097                    throws com.liferay.portal.kernel.exception.SystemException,
4098                            com.liferay.portlet.journal.NoSuchArticleException {
4099                    return getPersistence()
4100                                       .findByG_A_ST_Last(groupId, articleId, status,
4101                            orderByComparator);
4102            }
4103    
4104            /**
4105            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
4106            *
4107            * @param groupId the group ID
4108            * @param articleId the article ID
4109            * @param status the status
4110            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4111            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4112            * @throws SystemException if a system exception occurred
4113            */
4114            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
4115                    long groupId, java.lang.String articleId, int status,
4116                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4117                    throws com.liferay.portal.kernel.exception.SystemException {
4118                    return getPersistence()
4119                                       .fetchByG_A_ST_Last(groupId, articleId, status,
4120                            orderByComparator);
4121            }
4122    
4123            /**
4124            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
4125            *
4126            * @param id the primary key of the current journal article
4127            * @param groupId the group ID
4128            * @param articleId the article ID
4129            * @param status the status
4130            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4131            * @return the previous, current, and next journal article
4132            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4133            * @throws SystemException if a system exception occurred
4134            */
4135            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
4136                    long id, long groupId, java.lang.String articleId, int status,
4137                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4138                    throws com.liferay.portal.kernel.exception.SystemException,
4139                            com.liferay.portlet.journal.NoSuchArticleException {
4140                    return getPersistence()
4141                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
4142                            orderByComparator);
4143            }
4144    
4145            /**
4146            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
4147            *
4148            * <p>
4149            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4150            * </p>
4151            *
4152            * @param groupId the group ID
4153            * @param articleId the article ID
4154            * @param statuses the statuses
4155            * @return the matching journal articles
4156            * @throws SystemException if a system exception occurred
4157            */
4158            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
4159                    long groupId, java.lang.String articleId, int[] statuses)
4160                    throws com.liferay.portal.kernel.exception.SystemException {
4161                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
4162            }
4163    
4164            /**
4165            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
4166            *
4167            * <p>
4168            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4169            * </p>
4170            *
4171            * @param groupId the group ID
4172            * @param articleId the article ID
4173            * @param statuses the statuses
4174            * @param start the lower bound of the range of journal articles
4175            * @param end the upper bound of the range of journal articles (not inclusive)
4176            * @return the range of matching journal articles
4177            * @throws SystemException if a system exception occurred
4178            */
4179            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
4180                    long groupId, java.lang.String articleId, int[] statuses, int start,
4181                    int end) throws com.liferay.portal.kernel.exception.SystemException {
4182                    return getPersistence()
4183                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
4184            }
4185    
4186            /**
4187            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
4188            *
4189            * <p>
4190            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4191            * </p>
4192            *
4193            * @param groupId the group ID
4194            * @param articleId the article ID
4195            * @param statuses the statuses
4196            * @param start the lower bound of the range of journal articles
4197            * @param end the upper bound of the range of journal articles (not inclusive)
4198            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4199            * @return the ordered range of matching journal articles
4200            * @throws SystemException if a system exception occurred
4201            */
4202            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
4203                    long groupId, java.lang.String articleId, int[] statuses, int start,
4204                    int end,
4205                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4206                    throws com.liferay.portal.kernel.exception.SystemException {
4207                    return getPersistence()
4208                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
4209                            orderByComparator);
4210            }
4211    
4212            /**
4213            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
4214            *
4215            * @param groupId the group ID
4216            * @param articleId the article ID
4217            * @param status the status
4218            * @return the matching journal articles that the user has permission to view
4219            * @throws SystemException if a system exception occurred
4220            */
4221            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
4222                    long groupId, java.lang.String articleId, int status)
4223                    throws com.liferay.portal.kernel.exception.SystemException {
4224                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
4225            }
4226    
4227            /**
4228            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
4229            *
4230            * <p>
4231            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4232            * </p>
4233            *
4234            * @param groupId the group ID
4235            * @param articleId the article ID
4236            * @param status the status
4237            * @param start the lower bound of the range of journal articles
4238            * @param end the upper bound of the range of journal articles (not inclusive)
4239            * @return the range of matching journal articles that the user has permission to view
4240            * @throws SystemException if a system exception occurred
4241            */
4242            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
4243                    long groupId, java.lang.String articleId, int status, int start, int end)
4244                    throws com.liferay.portal.kernel.exception.SystemException {
4245                    return getPersistence()
4246                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
4247            }
4248    
4249            /**
4250            * 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;.
4251            *
4252            * <p>
4253            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4254            * </p>
4255            *
4256            * @param groupId the group ID
4257            * @param articleId the article ID
4258            * @param status the status
4259            * @param start the lower bound of the range of journal articles
4260            * @param end the upper bound of the range of journal articles (not inclusive)
4261            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4262            * @return the ordered range of matching journal articles that the user has permission to view
4263            * @throws SystemException if a system exception occurred
4264            */
4265            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
4266                    long groupId, java.lang.String articleId, int status, int start,
4267                    int end,
4268                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4269                    throws com.liferay.portal.kernel.exception.SystemException {
4270                    return getPersistence()
4271                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
4272                            orderByComparator);
4273            }
4274    
4275            /**
4276            * 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;.
4277            *
4278            * @param id the primary key of the current journal article
4279            * @param groupId the group ID
4280            * @param articleId the article ID
4281            * @param status the status
4282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4283            * @return the previous, current, and next journal article
4284            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4285            * @throws SystemException if a system exception occurred
4286            */
4287            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
4288                    long id, long groupId, java.lang.String articleId, int status,
4289                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4290                    throws com.liferay.portal.kernel.exception.SystemException,
4291                            com.liferay.portlet.journal.NoSuchArticleException {
4292                    return getPersistence()
4293                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
4294                            status, orderByComparator);
4295            }
4296    
4297            /**
4298            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
4299            *
4300            * @param groupId the group ID
4301            * @param articleId the article ID
4302            * @param statuses the statuses
4303            * @return the matching journal articles that the user has permission to view
4304            * @throws SystemException if a system exception occurred
4305            */
4306            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
4307                    long groupId, java.lang.String articleId, int[] statuses)
4308                    throws com.liferay.portal.kernel.exception.SystemException {
4309                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
4310            }
4311    
4312            /**
4313            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
4314            *
4315            * <p>
4316            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4317            * </p>
4318            *
4319            * @param groupId the group ID
4320            * @param articleId the article ID
4321            * @param statuses the statuses
4322            * @param start the lower bound of the range of journal articles
4323            * @param end the upper bound of the range of journal articles (not inclusive)
4324            * @return the range of matching journal articles that the user has permission to view
4325            * @throws SystemException if a system exception occurred
4326            */
4327            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
4328                    long groupId, java.lang.String articleId, int[] statuses, int start,
4329                    int end) throws com.liferay.portal.kernel.exception.SystemException {
4330                    return getPersistence()
4331                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
4332            }
4333    
4334            /**
4335            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
4336            *
4337            * <p>
4338            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4339            * </p>
4340            *
4341            * @param groupId the group ID
4342            * @param articleId the article ID
4343            * @param statuses the statuses
4344            * @param start the lower bound of the range of journal articles
4345            * @param end the upper bound of the range of journal articles (not inclusive)
4346            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4347            * @return the ordered range of matching journal articles that the user has permission to view
4348            * @throws SystemException if a system exception occurred
4349            */
4350            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
4351                    long groupId, java.lang.String articleId, int[] statuses, int start,
4352                    int end,
4353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4354                    throws com.liferay.portal.kernel.exception.SystemException {
4355                    return getPersistence()
4356                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
4357                            end, orderByComparator);
4358            }
4359    
4360            /**
4361            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4362            *
4363            * @param groupId the group ID
4364            * @param urlTitle the url title
4365            * @param status the status
4366            * @return the matching journal articles
4367            * @throws SystemException if a system exception occurred
4368            */
4369            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
4370                    long groupId, java.lang.String urlTitle, int status)
4371                    throws com.liferay.portal.kernel.exception.SystemException {
4372                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
4373            }
4374    
4375            /**
4376            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4377            *
4378            * <p>
4379            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4380            * </p>
4381            *
4382            * @param groupId the group ID
4383            * @param urlTitle the url title
4384            * @param status the status
4385            * @param start the lower bound of the range of journal articles
4386            * @param end the upper bound of the range of journal articles (not inclusive)
4387            * @return the range of matching journal articles
4388            * @throws SystemException if a system exception occurred
4389            */
4390            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
4391                    long groupId, java.lang.String urlTitle, int status, int start, int end)
4392                    throws com.liferay.portal.kernel.exception.SystemException {
4393                    return getPersistence()
4394                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
4395            }
4396    
4397            /**
4398            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4399            *
4400            * <p>
4401            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4402            * </p>
4403            *
4404            * @param groupId the group ID
4405            * @param urlTitle the url title
4406            * @param status the status
4407            * @param start the lower bound of the range of journal articles
4408            * @param end the upper bound of the range of journal articles (not inclusive)
4409            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4410            * @return the ordered range of matching journal articles
4411            * @throws SystemException if a system exception occurred
4412            */
4413            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
4414                    long groupId, java.lang.String urlTitle, int status, int start,
4415                    int end,
4416                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4417                    throws com.liferay.portal.kernel.exception.SystemException {
4418                    return getPersistence()
4419                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
4420                            orderByComparator);
4421            }
4422    
4423            /**
4424            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4425            *
4426            * @param groupId the group ID
4427            * @param urlTitle the url title
4428            * @param status the status
4429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4430            * @return the first matching journal article
4431            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4432            * @throws SystemException if a system exception occurred
4433            */
4434            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
4435                    long groupId, java.lang.String urlTitle, int status,
4436                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4437                    throws com.liferay.portal.kernel.exception.SystemException,
4438                            com.liferay.portlet.journal.NoSuchArticleException {
4439                    return getPersistence()
4440                                       .findByG_UT_ST_First(groupId, urlTitle, status,
4441                            orderByComparator);
4442            }
4443    
4444            /**
4445            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4446            *
4447            * @param groupId the group ID
4448            * @param urlTitle the url title
4449            * @param status the status
4450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4451            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4452            * @throws SystemException if a system exception occurred
4453            */
4454            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
4455                    long groupId, java.lang.String urlTitle, int status,
4456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4457                    throws com.liferay.portal.kernel.exception.SystemException {
4458                    return getPersistence()
4459                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
4460                            orderByComparator);
4461            }
4462    
4463            /**
4464            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4465            *
4466            * @param groupId the group ID
4467            * @param urlTitle the url title
4468            * @param status the status
4469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4470            * @return the last matching journal article
4471            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4472            * @throws SystemException if a system exception occurred
4473            */
4474            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
4475                    long groupId, java.lang.String urlTitle, int status,
4476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4477                    throws com.liferay.portal.kernel.exception.SystemException,
4478                            com.liferay.portlet.journal.NoSuchArticleException {
4479                    return getPersistence()
4480                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
4481                            orderByComparator);
4482            }
4483    
4484            /**
4485            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4486            *
4487            * @param groupId the group ID
4488            * @param urlTitle the url title
4489            * @param status the status
4490            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4491            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4492            * @throws SystemException if a system exception occurred
4493            */
4494            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
4495                    long groupId, java.lang.String urlTitle, int status,
4496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4497                    throws com.liferay.portal.kernel.exception.SystemException {
4498                    return getPersistence()
4499                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
4500                            orderByComparator);
4501            }
4502    
4503            /**
4504            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4505            *
4506            * @param id the primary key of the current journal article
4507            * @param groupId the group ID
4508            * @param urlTitle the url title
4509            * @param status the status
4510            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4511            * @return the previous, current, and next journal article
4512            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4513            * @throws SystemException if a system exception occurred
4514            */
4515            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
4516                    long id, long groupId, java.lang.String urlTitle, int status,
4517                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4518                    throws com.liferay.portal.kernel.exception.SystemException,
4519                            com.liferay.portlet.journal.NoSuchArticleException {
4520                    return getPersistence()
4521                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
4522                            orderByComparator);
4523            }
4524    
4525            /**
4526            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4527            *
4528            * @param groupId the group ID
4529            * @param urlTitle the url title
4530            * @param status the status
4531            * @return the matching journal articles that the user has permission to view
4532            * @throws SystemException if a system exception occurred
4533            */
4534            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
4535                    long groupId, java.lang.String urlTitle, int status)
4536                    throws com.liferay.portal.kernel.exception.SystemException {
4537                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
4538            }
4539    
4540            /**
4541            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4542            *
4543            * <p>
4544            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4545            * </p>
4546            *
4547            * @param groupId the group ID
4548            * @param urlTitle the url title
4549            * @param status the status
4550            * @param start the lower bound of the range of journal articles
4551            * @param end the upper bound of the range of journal articles (not inclusive)
4552            * @return the range of matching journal articles that the user has permission to view
4553            * @throws SystemException if a system exception occurred
4554            */
4555            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
4556                    long groupId, java.lang.String urlTitle, int status, int start, int end)
4557                    throws com.liferay.portal.kernel.exception.SystemException {
4558                    return getPersistence()
4559                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
4560            }
4561    
4562            /**
4563            * 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;.
4564            *
4565            * <p>
4566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4567            * </p>
4568            *
4569            * @param groupId the group ID
4570            * @param urlTitle the url title
4571            * @param status the status
4572            * @param start the lower bound of the range of journal articles
4573            * @param end the upper bound of the range of journal articles (not inclusive)
4574            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4575            * @return the ordered range of matching journal articles that the user has permission to view
4576            * @throws SystemException if a system exception occurred
4577            */
4578            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
4579                    long groupId, java.lang.String urlTitle, int status, int start,
4580                    int end,
4581                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4582                    throws com.liferay.portal.kernel.exception.SystemException {
4583                    return getPersistence()
4584                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
4585                            orderByComparator);
4586            }
4587    
4588            /**
4589            * 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;.
4590            *
4591            * @param id the primary key of the current journal article
4592            * @param groupId the group ID
4593            * @param urlTitle the url title
4594            * @param status the status
4595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4596            * @return the previous, current, and next journal article
4597            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4598            * @throws SystemException if a system exception occurred
4599            */
4600            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
4601                    long id, long groupId, java.lang.String urlTitle, int status,
4602                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4603                    throws com.liferay.portal.kernel.exception.SystemException,
4604                            com.liferay.portlet.journal.NoSuchArticleException {
4605                    return getPersistence()
4606                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
4607                            status, orderByComparator);
4608            }
4609    
4610            /**
4611            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4612            *
4613            * @param companyId the company ID
4614            * @param version the version
4615            * @param status the status
4616            * @return the matching journal articles
4617            * @throws SystemException if a system exception occurred
4618            */
4619            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
4620                    long companyId, double version, int status)
4621                    throws com.liferay.portal.kernel.exception.SystemException {
4622                    return getPersistence().findByC_V_ST(companyId, version, status);
4623            }
4624    
4625            /**
4626            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4627            *
4628            * <p>
4629            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4630            * </p>
4631            *
4632            * @param companyId the company ID
4633            * @param version the version
4634            * @param status the status
4635            * @param start the lower bound of the range of journal articles
4636            * @param end the upper bound of the range of journal articles (not inclusive)
4637            * @return the range of matching journal articles
4638            * @throws SystemException if a system exception occurred
4639            */
4640            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
4641                    long companyId, double version, int status, int start, int end)
4642                    throws com.liferay.portal.kernel.exception.SystemException {
4643                    return getPersistence()
4644                                       .findByC_V_ST(companyId, version, status, start, end);
4645            }
4646    
4647            /**
4648            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4649            *
4650            * <p>
4651            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4652            * </p>
4653            *
4654            * @param companyId the company ID
4655            * @param version the version
4656            * @param status the status
4657            * @param start the lower bound of the range of journal articles
4658            * @param end the upper bound of the range of journal articles (not inclusive)
4659            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4660            * @return the ordered range of matching journal articles
4661            * @throws SystemException if a system exception occurred
4662            */
4663            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
4664                    long companyId, double version, int status, int start, int end,
4665                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4666                    throws com.liferay.portal.kernel.exception.SystemException {
4667                    return getPersistence()
4668                                       .findByC_V_ST(companyId, version, status, start, end,
4669                            orderByComparator);
4670            }
4671    
4672            /**
4673            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4674            *
4675            * @param companyId the company ID
4676            * @param version the version
4677            * @param status the status
4678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4679            * @return the first matching journal article
4680            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4681            * @throws SystemException if a system exception occurred
4682            */
4683            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
4684                    long companyId, double version, int status,
4685                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4686                    throws com.liferay.portal.kernel.exception.SystemException,
4687                            com.liferay.portlet.journal.NoSuchArticleException {
4688                    return getPersistence()
4689                                       .findByC_V_ST_First(companyId, version, status,
4690                            orderByComparator);
4691            }
4692    
4693            /**
4694            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4695            *
4696            * @param companyId the company ID
4697            * @param version the version
4698            * @param status the status
4699            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4700            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4701            * @throws SystemException if a system exception occurred
4702            */
4703            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
4704                    long companyId, double version, int status,
4705                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4706                    throws com.liferay.portal.kernel.exception.SystemException {
4707                    return getPersistence()
4708                                       .fetchByC_V_ST_First(companyId, version, status,
4709                            orderByComparator);
4710            }
4711    
4712            /**
4713            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4714            *
4715            * @param companyId the company ID
4716            * @param version the version
4717            * @param status the status
4718            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4719            * @return the last matching journal article
4720            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4721            * @throws SystemException if a system exception occurred
4722            */
4723            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
4724                    long companyId, double version, int status,
4725                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4726                    throws com.liferay.portal.kernel.exception.SystemException,
4727                            com.liferay.portlet.journal.NoSuchArticleException {
4728                    return getPersistence()
4729                                       .findByC_V_ST_Last(companyId, version, status,
4730                            orderByComparator);
4731            }
4732    
4733            /**
4734            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4735            *
4736            * @param companyId the company ID
4737            * @param version the version
4738            * @param status the status
4739            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4740            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4741            * @throws SystemException if a system exception occurred
4742            */
4743            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
4744                    long companyId, double version, int status,
4745                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4746                    throws com.liferay.portal.kernel.exception.SystemException {
4747                    return getPersistence()
4748                                       .fetchByC_V_ST_Last(companyId, version, status,
4749                            orderByComparator);
4750            }
4751    
4752            /**
4753            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4754            *
4755            * @param id the primary key of the current journal article
4756            * @param companyId the company ID
4757            * @param version the version
4758            * @param status the status
4759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4760            * @return the previous, current, and next journal article
4761            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4762            * @throws SystemException if a system exception occurred
4763            */
4764            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
4765                    long id, long companyId, double version, int status,
4766                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4767                    throws com.liferay.portal.kernel.exception.SystemException,
4768                            com.liferay.portlet.journal.NoSuchArticleException {
4769                    return getPersistence()
4770                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
4771                            orderByComparator);
4772            }
4773    
4774            /**
4775            * Returns all the journal articles.
4776            *
4777            * @return the journal articles
4778            * @throws SystemException if a system exception occurred
4779            */
4780            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
4781                    throws com.liferay.portal.kernel.exception.SystemException {
4782                    return getPersistence().findAll();
4783            }
4784    
4785            /**
4786            * Returns a range of all the journal articles.
4787            *
4788            * <p>
4789            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4790            * </p>
4791            *
4792            * @param start the lower bound of the range of journal articles
4793            * @param end the upper bound of the range of journal articles (not inclusive)
4794            * @return the range of journal articles
4795            * @throws SystemException if a system exception occurred
4796            */
4797            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
4798                    int start, int end)
4799                    throws com.liferay.portal.kernel.exception.SystemException {
4800                    return getPersistence().findAll(start, end);
4801            }
4802    
4803            /**
4804            * Returns an ordered range of all the journal articles.
4805            *
4806            * <p>
4807            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4808            * </p>
4809            *
4810            * @param start the lower bound of the range of journal articles
4811            * @param end the upper bound of the range of journal articles (not inclusive)
4812            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4813            * @return the ordered range of journal articles
4814            * @throws SystemException if a system exception occurred
4815            */
4816            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
4817                    int start, int end,
4818                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4819                    throws com.liferay.portal.kernel.exception.SystemException {
4820                    return getPersistence().findAll(start, end, orderByComparator);
4821            }
4822    
4823            /**
4824            * Removes all the journal articles where uuid = &#63; from the database.
4825            *
4826            * @param uuid the uuid
4827            * @throws SystemException if a system exception occurred
4828            */
4829            public static void removeByUuid(java.lang.String uuid)
4830                    throws com.liferay.portal.kernel.exception.SystemException {
4831                    getPersistence().removeByUuid(uuid);
4832            }
4833    
4834            /**
4835            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
4836            *
4837            * @param uuid the uuid
4838            * @param groupId the group ID
4839            * @return the journal article that was removed
4840            * @throws SystemException if a system exception occurred
4841            */
4842            public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G(
4843                    java.lang.String uuid, long groupId)
4844                    throws com.liferay.portal.kernel.exception.SystemException,
4845                            com.liferay.portlet.journal.NoSuchArticleException {
4846                    return getPersistence().removeByUUID_G(uuid, groupId);
4847            }
4848    
4849            /**
4850            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
4851            *
4852            * @param resourcePrimKey the resource prim key
4853            * @throws SystemException if a system exception occurred
4854            */
4855            public static void removeByResourcePrimKey(long resourcePrimKey)
4856                    throws com.liferay.portal.kernel.exception.SystemException {
4857                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
4858            }
4859    
4860            /**
4861            * Removes all the journal articles where groupId = &#63; from the database.
4862            *
4863            * @param groupId the group ID
4864            * @throws SystemException if a system exception occurred
4865            */
4866            public static void removeByGroupId(long groupId)
4867                    throws com.liferay.portal.kernel.exception.SystemException {
4868                    getPersistence().removeByGroupId(groupId);
4869            }
4870    
4871            /**
4872            * Removes all the journal articles where companyId = &#63; from the database.
4873            *
4874            * @param companyId the company ID
4875            * @throws SystemException if a system exception occurred
4876            */
4877            public static void removeByCompanyId(long companyId)
4878                    throws com.liferay.portal.kernel.exception.SystemException {
4879                    getPersistence().removeByCompanyId(companyId);
4880            }
4881    
4882            /**
4883            * Removes all the journal articles where structureId = &#63; from the database.
4884            *
4885            * @param structureId the structure ID
4886            * @throws SystemException if a system exception occurred
4887            */
4888            public static void removeByStructureId(java.lang.String structureId)
4889                    throws com.liferay.portal.kernel.exception.SystemException {
4890                    getPersistence().removeByStructureId(structureId);
4891            }
4892    
4893            /**
4894            * Removes all the journal articles where templateId = &#63; from the database.
4895            *
4896            * @param templateId the template ID
4897            * @throws SystemException if a system exception occurred
4898            */
4899            public static void removeByTemplateId(java.lang.String templateId)
4900                    throws com.liferay.portal.kernel.exception.SystemException {
4901                    getPersistence().removeByTemplateId(templateId);
4902            }
4903    
4904            /**
4905            * Removes all the journal articles where smallImageId = &#63; from the database.
4906            *
4907            * @param smallImageId the small image ID
4908            * @throws SystemException if a system exception occurred
4909            */
4910            public static void removeBySmallImageId(long smallImageId)
4911                    throws com.liferay.portal.kernel.exception.SystemException {
4912                    getPersistence().removeBySmallImageId(smallImageId);
4913            }
4914    
4915            /**
4916            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
4917            *
4918            * @param resourcePrimKey the resource prim key
4919            * @param status the status
4920            * @throws SystemException if a system exception occurred
4921            */
4922            public static void removeByR_ST(long resourcePrimKey, int status)
4923                    throws com.liferay.portal.kernel.exception.SystemException {
4924                    getPersistence().removeByR_ST(resourcePrimKey, status);
4925            }
4926    
4927            /**
4928            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
4929            *
4930            * @param groupId the group ID
4931            * @param articleId the article ID
4932            * @throws SystemException if a system exception occurred
4933            */
4934            public static void removeByG_A(long groupId, java.lang.String articleId)
4935                    throws com.liferay.portal.kernel.exception.SystemException {
4936                    getPersistence().removeByG_A(groupId, articleId);
4937            }
4938    
4939            /**
4940            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
4941            *
4942            * @param groupId the group ID
4943            * @param urlTitle the url title
4944            * @throws SystemException if a system exception occurred
4945            */
4946            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
4947                    throws com.liferay.portal.kernel.exception.SystemException {
4948                    getPersistence().removeByG_UT(groupId, urlTitle);
4949            }
4950    
4951            /**
4952            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
4953            *
4954            * @param groupId the group ID
4955            * @param structureId the structure ID
4956            * @throws SystemException if a system exception occurred
4957            */
4958            public static void removeByG_S(long groupId, java.lang.String structureId)
4959                    throws com.liferay.portal.kernel.exception.SystemException {
4960                    getPersistence().removeByG_S(groupId, structureId);
4961            }
4962    
4963            /**
4964            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
4965            *
4966            * @param groupId the group ID
4967            * @param templateId the template ID
4968            * @throws SystemException if a system exception occurred
4969            */
4970            public static void removeByG_T(long groupId, java.lang.String templateId)
4971                    throws com.liferay.portal.kernel.exception.SystemException {
4972                    getPersistence().removeByG_T(groupId, templateId);
4973            }
4974    
4975            /**
4976            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
4977            *
4978            * @param groupId the group ID
4979            * @param layoutUuid the layout uuid
4980            * @throws SystemException if a system exception occurred
4981            */
4982            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
4983                    throws com.liferay.portal.kernel.exception.SystemException {
4984                    getPersistence().removeByG_L(groupId, layoutUuid);
4985            }
4986    
4987            /**
4988            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4989            *
4990            * @param groupId the group ID
4991            * @param status the status
4992            * @throws SystemException if a system exception occurred
4993            */
4994            public static void removeByG_ST(long groupId, int status)
4995                    throws com.liferay.portal.kernel.exception.SystemException {
4996                    getPersistence().removeByG_ST(groupId, status);
4997            }
4998    
4999            /**
5000            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
5001            *
5002            * @param companyId the company ID
5003            * @param version the version
5004            * @throws SystemException if a system exception occurred
5005            */
5006            public static void removeByC_V(long companyId, double version)
5007                    throws com.liferay.portal.kernel.exception.SystemException {
5008                    getPersistence().removeByC_V(companyId, version);
5009            }
5010    
5011            /**
5012            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
5013            *
5014            * @param companyId the company ID
5015            * @param status the status
5016            * @throws SystemException if a system exception occurred
5017            */
5018            public static void removeByC_ST(long companyId, int status)
5019                    throws com.liferay.portal.kernel.exception.SystemException {
5020                    getPersistence().removeByC_ST(companyId, status);
5021            }
5022    
5023            /**
5024            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5025            *
5026            * @param groupId the group ID
5027            * @param classNameId the class name ID
5028            * @param classPK the class p k
5029            * @throws SystemException if a system exception occurred
5030            */
5031            public static void removeByG_C_C(long groupId, long classNameId,
5032                    long classPK)
5033                    throws com.liferay.portal.kernel.exception.SystemException {
5034                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5035            }
5036    
5037            /**
5038            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
5039            *
5040            * @param groupId the group ID
5041            * @param classNameId the class name ID
5042            * @param structureId the structure ID
5043            * @return the journal article that was removed
5044            * @throws SystemException if a system exception occurred
5045            */
5046            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
5047                    long groupId, long classNameId, java.lang.String structureId)
5048                    throws com.liferay.portal.kernel.exception.SystemException,
5049                            com.liferay.portlet.journal.NoSuchArticleException {
5050                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
5051            }
5052    
5053            /**
5054            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
5055            *
5056            * @param groupId the group ID
5057            * @param classNameId the class name ID
5058            * @param templateId the template ID
5059            * @throws SystemException if a system exception occurred
5060            */
5061            public static void removeByG_C_T(long groupId, long classNameId,
5062                    java.lang.String templateId)
5063                    throws com.liferay.portal.kernel.exception.SystemException {
5064                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
5065            }
5066    
5067            /**
5068            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
5069            *
5070            * @param groupId the group ID
5071            * @param classNameId the class name ID
5072            * @param layoutUuid the layout uuid
5073            * @throws SystemException if a system exception occurred
5074            */
5075            public static void removeByG_C_L(long groupId, long classNameId,
5076                    java.lang.String layoutUuid)
5077                    throws com.liferay.portal.kernel.exception.SystemException {
5078                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
5079            }
5080    
5081            /**
5082            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
5083            *
5084            * @param groupId the group ID
5085            * @param articleId the article ID
5086            * @param version the version
5087            * @return the journal article that was removed
5088            * @throws SystemException if a system exception occurred
5089            */
5090            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
5091                    long groupId, java.lang.String articleId, double version)
5092                    throws com.liferay.portal.kernel.exception.SystemException,
5093                            com.liferay.portlet.journal.NoSuchArticleException {
5094                    return getPersistence().removeByG_A_V(groupId, articleId, version);
5095            }
5096    
5097            /**
5098            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
5099            *
5100            * @param groupId the group ID
5101            * @param articleId the article ID
5102            * @param status the status
5103            * @throws SystemException if a system exception occurred
5104            */
5105            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
5106                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5107                    getPersistence().removeByG_A_ST(groupId, articleId, status);
5108            }
5109    
5110            /**
5111            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
5112            *
5113            * @param groupId the group ID
5114            * @param urlTitle the url title
5115            * @param status the status
5116            * @throws SystemException if a system exception occurred
5117            */
5118            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
5119                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5120                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
5121            }
5122    
5123            /**
5124            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
5125            *
5126            * @param companyId the company ID
5127            * @param version the version
5128            * @param status the status
5129            * @throws SystemException if a system exception occurred
5130            */
5131            public static void removeByC_V_ST(long companyId, double version, int status)
5132                    throws com.liferay.portal.kernel.exception.SystemException {
5133                    getPersistence().removeByC_V_ST(companyId, version, status);
5134            }
5135    
5136            /**
5137            * Removes all the journal articles from the database.
5138            *
5139            * @throws SystemException if a system exception occurred
5140            */
5141            public static void removeAll()
5142                    throws com.liferay.portal.kernel.exception.SystemException {
5143                    getPersistence().removeAll();
5144            }
5145    
5146            /**
5147            * Returns the number of journal articles where uuid = &#63;.
5148            *
5149            * @param uuid the uuid
5150            * @return the number of matching journal articles
5151            * @throws SystemException if a system exception occurred
5152            */
5153            public static int countByUuid(java.lang.String uuid)
5154                    throws com.liferay.portal.kernel.exception.SystemException {
5155                    return getPersistence().countByUuid(uuid);
5156            }
5157    
5158            /**
5159            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
5160            *
5161            * @param uuid the uuid
5162            * @param groupId the group ID
5163            * @return the number of matching journal articles
5164            * @throws SystemException if a system exception occurred
5165            */
5166            public static int countByUUID_G(java.lang.String uuid, long groupId)
5167                    throws com.liferay.portal.kernel.exception.SystemException {
5168                    return getPersistence().countByUUID_G(uuid, groupId);
5169            }
5170    
5171            /**
5172            * Returns the number of journal articles where resourcePrimKey = &#63;.
5173            *
5174            * @param resourcePrimKey the resource prim key
5175            * @return the number of matching journal articles
5176            * @throws SystemException if a system exception occurred
5177            */
5178            public static int countByResourcePrimKey(long resourcePrimKey)
5179                    throws com.liferay.portal.kernel.exception.SystemException {
5180                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
5181            }
5182    
5183            /**
5184            * Returns the number of journal articles where groupId = &#63;.
5185            *
5186            * @param groupId the group ID
5187            * @return the number of matching journal articles
5188            * @throws SystemException if a system exception occurred
5189            */
5190            public static int countByGroupId(long groupId)
5191                    throws com.liferay.portal.kernel.exception.SystemException {
5192                    return getPersistence().countByGroupId(groupId);
5193            }
5194    
5195            /**
5196            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
5197            *
5198            * @param groupId the group ID
5199            * @return the number of matching journal articles that the user has permission to view
5200            * @throws SystemException if a system exception occurred
5201            */
5202            public static int filterCountByGroupId(long groupId)
5203                    throws com.liferay.portal.kernel.exception.SystemException {
5204                    return getPersistence().filterCountByGroupId(groupId);
5205            }
5206    
5207            /**
5208            * Returns the number of journal articles where companyId = &#63;.
5209            *
5210            * @param companyId the company ID
5211            * @return the number of matching journal articles
5212            * @throws SystemException if a system exception occurred
5213            */
5214            public static int countByCompanyId(long companyId)
5215                    throws com.liferay.portal.kernel.exception.SystemException {
5216                    return getPersistence().countByCompanyId(companyId);
5217            }
5218    
5219            /**
5220            * Returns the number of journal articles where structureId = &#63;.
5221            *
5222            * @param structureId the structure ID
5223            * @return the number of matching journal articles
5224            * @throws SystemException if a system exception occurred
5225            */
5226            public static int countByStructureId(java.lang.String structureId)
5227                    throws com.liferay.portal.kernel.exception.SystemException {
5228                    return getPersistence().countByStructureId(structureId);
5229            }
5230    
5231            /**
5232            * Returns the number of journal articles where templateId = &#63;.
5233            *
5234            * @param templateId the template ID
5235            * @return the number of matching journal articles
5236            * @throws SystemException if a system exception occurred
5237            */
5238            public static int countByTemplateId(java.lang.String templateId)
5239                    throws com.liferay.portal.kernel.exception.SystemException {
5240                    return getPersistence().countByTemplateId(templateId);
5241            }
5242    
5243            /**
5244            * Returns the number of journal articles where smallImageId = &#63;.
5245            *
5246            * @param smallImageId the small image ID
5247            * @return the number of matching journal articles
5248            * @throws SystemException if a system exception occurred
5249            */
5250            public static int countBySmallImageId(long smallImageId)
5251                    throws com.liferay.portal.kernel.exception.SystemException {
5252                    return getPersistence().countBySmallImageId(smallImageId);
5253            }
5254    
5255            /**
5256            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
5257            *
5258            * @param resourcePrimKey the resource prim key
5259            * @param status the status
5260            * @return the number of matching journal articles
5261            * @throws SystemException if a system exception occurred
5262            */
5263            public static int countByR_ST(long resourcePrimKey, int status)
5264                    throws com.liferay.portal.kernel.exception.SystemException {
5265                    return getPersistence().countByR_ST(resourcePrimKey, status);
5266            }
5267    
5268            /**
5269            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
5270            *
5271            * @param groupId the group ID
5272            * @param articleId the article ID
5273            * @return the number of matching journal articles
5274            * @throws SystemException if a system exception occurred
5275            */
5276            public static int countByG_A(long groupId, java.lang.String articleId)
5277                    throws com.liferay.portal.kernel.exception.SystemException {
5278                    return getPersistence().countByG_A(groupId, articleId);
5279            }
5280    
5281            /**
5282            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
5283            *
5284            * @param groupId the group ID
5285            * @param articleId the article ID
5286            * @return the number of matching journal articles that the user has permission to view
5287            * @throws SystemException if a system exception occurred
5288            */
5289            public static int filterCountByG_A(long groupId, java.lang.String articleId)
5290                    throws com.liferay.portal.kernel.exception.SystemException {
5291                    return getPersistence().filterCountByG_A(groupId, articleId);
5292            }
5293    
5294            /**
5295            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
5296            *
5297            * @param groupId the group ID
5298            * @param urlTitle the url title
5299            * @return the number of matching journal articles
5300            * @throws SystemException if a system exception occurred
5301            */
5302            public static int countByG_UT(long groupId, java.lang.String urlTitle)
5303                    throws com.liferay.portal.kernel.exception.SystemException {
5304                    return getPersistence().countByG_UT(groupId, urlTitle);
5305            }
5306    
5307            /**
5308            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
5309            *
5310            * @param groupId the group ID
5311            * @param urlTitle the url title
5312            * @return the number of matching journal articles that the user has permission to view
5313            * @throws SystemException if a system exception occurred
5314            */
5315            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
5316                    throws com.liferay.portal.kernel.exception.SystemException {
5317                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
5318            }
5319    
5320            /**
5321            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
5322            *
5323            * @param groupId the group ID
5324            * @param structureId the structure ID
5325            * @return the number of matching journal articles
5326            * @throws SystemException if a system exception occurred
5327            */
5328            public static int countByG_S(long groupId, java.lang.String structureId)
5329                    throws com.liferay.portal.kernel.exception.SystemException {
5330                    return getPersistence().countByG_S(groupId, structureId);
5331            }
5332    
5333            /**
5334            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
5335            *
5336            * @param groupId the group ID
5337            * @param structureId the structure ID
5338            * @return the number of matching journal articles that the user has permission to view
5339            * @throws SystemException if a system exception occurred
5340            */
5341            public static int filterCountByG_S(long groupId,
5342                    java.lang.String structureId)
5343                    throws com.liferay.portal.kernel.exception.SystemException {
5344                    return getPersistence().filterCountByG_S(groupId, structureId);
5345            }
5346    
5347            /**
5348            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
5349            *
5350            * @param groupId the group ID
5351            * @param templateId the template ID
5352            * @return the number of matching journal articles
5353            * @throws SystemException if a system exception occurred
5354            */
5355            public static int countByG_T(long groupId, java.lang.String templateId)
5356                    throws com.liferay.portal.kernel.exception.SystemException {
5357                    return getPersistence().countByG_T(groupId, templateId);
5358            }
5359    
5360            /**
5361            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
5362            *
5363            * @param groupId the group ID
5364            * @param templateId the template ID
5365            * @return the number of matching journal articles that the user has permission to view
5366            * @throws SystemException if a system exception occurred
5367            */
5368            public static int filterCountByG_T(long groupId, java.lang.String templateId)
5369                    throws com.liferay.portal.kernel.exception.SystemException {
5370                    return getPersistence().filterCountByG_T(groupId, templateId);
5371            }
5372    
5373            /**
5374            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
5375            *
5376            * @param groupId the group ID
5377            * @param layoutUuid the layout uuid
5378            * @return the number of matching journal articles
5379            * @throws SystemException if a system exception occurred
5380            */
5381            public static int countByG_L(long groupId, java.lang.String layoutUuid)
5382                    throws com.liferay.portal.kernel.exception.SystemException {
5383                    return getPersistence().countByG_L(groupId, layoutUuid);
5384            }
5385    
5386            /**
5387            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
5388            *
5389            * @param groupId the group ID
5390            * @param layoutUuid the layout uuid
5391            * @return the number of matching journal articles that the user has permission to view
5392            * @throws SystemException if a system exception occurred
5393            */
5394            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
5395                    throws com.liferay.portal.kernel.exception.SystemException {
5396                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
5397            }
5398    
5399            /**
5400            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
5401            *
5402            * @param groupId the group ID
5403            * @param status the status
5404            * @return the number of matching journal articles
5405            * @throws SystemException if a system exception occurred
5406            */
5407            public static int countByG_ST(long groupId, int status)
5408                    throws com.liferay.portal.kernel.exception.SystemException {
5409                    return getPersistence().countByG_ST(groupId, status);
5410            }
5411    
5412            /**
5413            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
5414            *
5415            * @param groupId the group ID
5416            * @param status the status
5417            * @return the number of matching journal articles that the user has permission to view
5418            * @throws SystemException if a system exception occurred
5419            */
5420            public static int filterCountByG_ST(long groupId, int status)
5421                    throws com.liferay.portal.kernel.exception.SystemException {
5422                    return getPersistence().filterCountByG_ST(groupId, status);
5423            }
5424    
5425            /**
5426            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
5427            *
5428            * @param companyId the company ID
5429            * @param version the version
5430            * @return the number of matching journal articles
5431            * @throws SystemException if a system exception occurred
5432            */
5433            public static int countByC_V(long companyId, double version)
5434                    throws com.liferay.portal.kernel.exception.SystemException {
5435                    return getPersistence().countByC_V(companyId, version);
5436            }
5437    
5438            /**
5439            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
5440            *
5441            * @param companyId the company ID
5442            * @param status the status
5443            * @return the number of matching journal articles
5444            * @throws SystemException if a system exception occurred
5445            */
5446            public static int countByC_ST(long companyId, int status)
5447                    throws com.liferay.portal.kernel.exception.SystemException {
5448                    return getPersistence().countByC_ST(companyId, status);
5449            }
5450    
5451            /**
5452            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5453            *
5454            * @param groupId the group ID
5455            * @param classNameId the class name ID
5456            * @param classPK the class p k
5457            * @return the number of matching journal articles
5458            * @throws SystemException if a system exception occurred
5459            */
5460            public static int countByG_C_C(long groupId, long classNameId, long classPK)
5461                    throws com.liferay.portal.kernel.exception.SystemException {
5462                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5463            }
5464    
5465            /**
5466            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5467            *
5468            * @param groupId the group ID
5469            * @param classNameId the class name ID
5470            * @param classPK the class p k
5471            * @return the number of matching journal articles that the user has permission to view
5472            * @throws SystemException if a system exception occurred
5473            */
5474            public static int filterCountByG_C_C(long groupId, long classNameId,
5475                    long classPK)
5476                    throws com.liferay.portal.kernel.exception.SystemException {
5477                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5478            }
5479    
5480            /**
5481            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
5482            *
5483            * @param groupId the group ID
5484            * @param classNameId the class name ID
5485            * @param structureId the structure ID
5486            * @return the number of matching journal articles
5487            * @throws SystemException if a system exception occurred
5488            */
5489            public static int countByG_C_S(long groupId, long classNameId,
5490                    java.lang.String structureId)
5491                    throws com.liferay.portal.kernel.exception.SystemException {
5492                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
5493            }
5494    
5495            /**
5496            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5497            *
5498            * @param groupId the group ID
5499            * @param classNameId the class name ID
5500            * @param templateId the template ID
5501            * @return the number of matching journal articles
5502            * @throws SystemException if a system exception occurred
5503            */
5504            public static int countByG_C_T(long groupId, long classNameId,
5505                    java.lang.String templateId)
5506                    throws com.liferay.portal.kernel.exception.SystemException {
5507                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
5508            }
5509    
5510            /**
5511            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5512            *
5513            * @param groupId the group ID
5514            * @param classNameId the class name ID
5515            * @param templateId the template ID
5516            * @return the number of matching journal articles that the user has permission to view
5517            * @throws SystemException if a system exception occurred
5518            */
5519            public static int filterCountByG_C_T(long groupId, long classNameId,
5520                    java.lang.String templateId)
5521                    throws com.liferay.portal.kernel.exception.SystemException {
5522                    return getPersistence()
5523                                       .filterCountByG_C_T(groupId, classNameId, templateId);
5524            }
5525    
5526            /**
5527            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5528            *
5529            * @param groupId the group ID
5530            * @param classNameId the class name ID
5531            * @param layoutUuid the layout uuid
5532            * @return the number of matching journal articles
5533            * @throws SystemException if a system exception occurred
5534            */
5535            public static int countByG_C_L(long groupId, long classNameId,
5536                    java.lang.String layoutUuid)
5537                    throws com.liferay.portal.kernel.exception.SystemException {
5538                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
5539            }
5540    
5541            /**
5542            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5543            *
5544            * @param groupId the group ID
5545            * @param classNameId the class name ID
5546            * @param layoutUuid the layout uuid
5547            * @return the number of matching journal articles that the user has permission to view
5548            * @throws SystemException if a system exception occurred
5549            */
5550            public static int filterCountByG_C_L(long groupId, long classNameId,
5551                    java.lang.String layoutUuid)
5552                    throws com.liferay.portal.kernel.exception.SystemException {
5553                    return getPersistence()
5554                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
5555            }
5556    
5557            /**
5558            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
5559            *
5560            * @param groupId the group ID
5561            * @param articleId the article ID
5562            * @param version the version
5563            * @return the number of matching journal articles
5564            * @throws SystemException if a system exception occurred
5565            */
5566            public static int countByG_A_V(long groupId, java.lang.String articleId,
5567                    double version)
5568                    throws com.liferay.portal.kernel.exception.SystemException {
5569                    return getPersistence().countByG_A_V(groupId, articleId, version);
5570            }
5571    
5572            /**
5573            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
5574            *
5575            * @param groupId the group ID
5576            * @param articleId the article ID
5577            * @param status the status
5578            * @return the number of matching journal articles
5579            * @throws SystemException if a system exception occurred
5580            */
5581            public static int countByG_A_ST(long groupId, java.lang.String articleId,
5582                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5583                    return getPersistence().countByG_A_ST(groupId, articleId, status);
5584            }
5585    
5586            /**
5587            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
5588            *
5589            * @param groupId the group ID
5590            * @param articleId the article ID
5591            * @param statuses the statuses
5592            * @return the number of matching journal articles
5593            * @throws SystemException if a system exception occurred
5594            */
5595            public static int countByG_A_ST(long groupId, java.lang.String articleId,
5596                    int[] statuses)
5597                    throws com.liferay.portal.kernel.exception.SystemException {
5598                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
5599            }
5600    
5601            /**
5602            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
5603            *
5604            * @param groupId the group ID
5605            * @param articleId the article ID
5606            * @param status the status
5607            * @return the number of matching journal articles that the user has permission to view
5608            * @throws SystemException if a system exception occurred
5609            */
5610            public static int filterCountByG_A_ST(long groupId,
5611                    java.lang.String articleId, int status)
5612                    throws com.liferay.portal.kernel.exception.SystemException {
5613                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
5614            }
5615    
5616            /**
5617            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
5618            *
5619            * @param groupId the group ID
5620            * @param articleId the article ID
5621            * @param statuses the statuses
5622            * @return the number of matching journal articles that the user has permission to view
5623            * @throws SystemException if a system exception occurred
5624            */
5625            public static int filterCountByG_A_ST(long groupId,
5626                    java.lang.String articleId, int[] statuses)
5627                    throws com.liferay.portal.kernel.exception.SystemException {
5628                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
5629            }
5630    
5631            /**
5632            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5633            *
5634            * @param groupId the group ID
5635            * @param urlTitle the url title
5636            * @param status the status
5637            * @return the number of matching journal articles
5638            * @throws SystemException if a system exception occurred
5639            */
5640            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
5641                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5642                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
5643            }
5644    
5645            /**
5646            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5647            *
5648            * @param groupId the group ID
5649            * @param urlTitle the url title
5650            * @param status the status
5651            * @return the number of matching journal articles that the user has permission to view
5652            * @throws SystemException if a system exception occurred
5653            */
5654            public static int filterCountByG_UT_ST(long groupId,
5655                    java.lang.String urlTitle, int status)
5656                    throws com.liferay.portal.kernel.exception.SystemException {
5657                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
5658            }
5659    
5660            /**
5661            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
5662            *
5663            * @param companyId the company ID
5664            * @param version the version
5665            * @param status the status
5666            * @return the number of matching journal articles
5667            * @throws SystemException if a system exception occurred
5668            */
5669            public static int countByC_V_ST(long companyId, double version, int status)
5670                    throws com.liferay.portal.kernel.exception.SystemException {
5671                    return getPersistence().countByC_V_ST(companyId, version, status);
5672            }
5673    
5674            /**
5675            * Returns the number of journal articles.
5676            *
5677            * @return the number of journal articles
5678            * @throws SystemException if a system exception occurred
5679            */
5680            public static int countAll()
5681                    throws com.liferay.portal.kernel.exception.SystemException {
5682                    return getPersistence().countAll();
5683            }
5684    
5685            public static JournalArticlePersistence getPersistence() {
5686                    if (_persistence == null) {
5687                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
5688    
5689                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
5690                                    "_persistence");
5691                    }
5692    
5693                    return _persistence;
5694            }
5695    
5696            /**
5697             * @deprecated
5698             */
5699            public void setPersistence(JournalArticlePersistence persistence) {
5700            }
5701    
5702            private static JournalArticlePersistence _persistence;
5703    }