001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.journal.model.JournalArticle;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see JournalArticlePersistence
037     * @see JournalArticlePersistenceImpl
038     * @generated
039     */
040    public class JournalArticleUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(JournalArticle journalArticle) {
058                    getPersistence().clearCache(journalArticle);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<JournalArticle> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<JournalArticle> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalArticle> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static JournalArticle update(JournalArticle journalArticle)
101                    throws SystemException {
102                    return getPersistence().update(journalArticle);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static JournalArticle update(JournalArticle journalArticle,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(journalArticle, serviceContext);
111            }
112    
113            /**
114            * Returns all the journal articles where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching journal articles
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the journal articles where uuid = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of journal articles
135            * @param end the upper bound of the range of journal articles (not inclusive)
136            * @return the range of matching journal articles
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the journal articles where uuid = &#63;.
147            *
148            * <p>
149            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of journal articles
154            * @param end the upper bound of the range of journal articles (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching journal articles
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first journal article in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching journal article
172            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.kernel.exception.SystemException,
179                            com.liferay.portlet.journal.NoSuchArticleException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first journal article in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last journal article in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching journal article
204            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.kernel.exception.SystemException,
211                            com.liferay.portlet.journal.NoSuchArticleException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last journal article in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
232            *
233            * @param id the primary key of the current journal article
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next journal article
237            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
241                    long id, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException,
244                            com.liferay.portlet.journal.NoSuchArticleException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the journal articles where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of journal articles where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching journal articles
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * 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.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching journal article
278            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.journal.NoSuchArticleException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * 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.
290            *
291            * @param uuid the uuid
292            * @param groupId the group ID
293            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
297                    java.lang.String uuid, long groupId)
298                    throws com.liferay.portal.kernel.exception.SystemException {
299                    return getPersistence().fetchByUUID_G(uuid, groupId);
300            }
301    
302            /**
303            * 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.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @param retrieveFromCache whether to use the finder cache
308            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
312                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
315            }
316    
317            /**
318            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param groupId the group ID
322            * @return the journal article that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.journal.NoSuchArticleException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param groupId the group ID
337            * @return the number of matching journal articles
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUUID_G(java.lang.String uuid, long groupId)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching journal articles
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
354                    java.lang.String uuid, long companyId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().findByUuid_C(uuid, companyId);
357            }
358    
359            /**
360            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of journal articles
369            * @param end the upper bound of the range of journal articles (not inclusive)
370            * @return the range of matching journal articles
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
374                    java.lang.String uuid, long companyId, int start, int end)
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
377            }
378    
379            /**
380            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
381            *
382            * <p>
383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
384            * </p>
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param start the lower bound of the range of journal articles
389            * @param end the upper bound of the range of journal articles (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching journal articles
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
395                    java.lang.String uuid, long companyId, int start, int end,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence()
399                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
400            }
401    
402            /**
403            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching journal article
409            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First(
413                    java.lang.String uuid, long companyId,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.kernel.exception.SystemException,
416                            com.liferay.portlet.journal.NoSuchArticleException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First(
431                    java.lang.String uuid, long companyId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException {
434                    return getPersistence()
435                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
436            }
437    
438            /**
439            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching journal article
445            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last(
449                    java.lang.String uuid, long companyId,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.journal.NoSuchArticleException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last(
467                    java.lang.String uuid, long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
472            }
473    
474            /**
475            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param id the primary key of the current journal article
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next journal article
482            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext(
486                    long id, java.lang.String uuid, long companyId,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException,
489                            com.liferay.portlet.journal.NoSuchArticleException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @throws SystemException if a system exception occurred
501            */
502            public static void removeByUuid_C(java.lang.String uuid, long companyId)
503                    throws com.liferay.portal.kernel.exception.SystemException {
504                    getPersistence().removeByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the number of matching journal articles
513            * @throws SystemException if a system exception occurred
514            */
515            public static int countByUuid_C(java.lang.String uuid, long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().countByUuid_C(uuid, companyId);
518            }
519    
520            /**
521            * Returns all the journal articles where resourcePrimKey = &#63;.
522            *
523            * @param resourcePrimKey the resource prim key
524            * @return the matching journal articles
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
528                    long resourcePrimKey)
529                    throws com.liferay.portal.kernel.exception.SystemException {
530                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
531            }
532    
533            /**
534            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
535            *
536            * <p>
537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
538            * </p>
539            *
540            * @param resourcePrimKey the resource prim key
541            * @param start the lower bound of the range of journal articles
542            * @param end the upper bound of the range of journal articles (not inclusive)
543            * @return the range of matching journal articles
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
547                    long resourcePrimKey, int start, int end)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence()
550                                       .findByResourcePrimKey(resourcePrimKey, start, end);
551            }
552    
553            /**
554            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
555            *
556            * <p>
557            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
558            * </p>
559            *
560            * @param resourcePrimKey the resource prim key
561            * @param start the lower bound of the range of journal articles
562            * @param end the upper bound of the range of journal articles (not inclusive)
563            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
564            * @return the ordered range of matching journal articles
565            * @throws SystemException if a system exception occurred
566            */
567            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
568                    long resourcePrimKey, int start, int end,
569                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
570                    throws com.liferay.portal.kernel.exception.SystemException {
571                    return getPersistence()
572                                       .findByResourcePrimKey(resourcePrimKey, start, end,
573                            orderByComparator);
574            }
575    
576            /**
577            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
578            *
579            * @param resourcePrimKey the resource prim key
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 findByResourcePrimKey_First(
586                    long resourcePrimKey,
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()
591                                       .findByResourcePrimKey_First(resourcePrimKey,
592                            orderByComparator);
593            }
594    
595            /**
596            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
597            *
598            * @param resourcePrimKey the resource prim key
599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
600            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
601            * @throws SystemException if a system exception occurred
602            */
603            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First(
604                    long resourcePrimKey,
605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
606                    throws com.liferay.portal.kernel.exception.SystemException {
607                    return getPersistence()
608                                       .fetchByResourcePrimKey_First(resourcePrimKey,
609                            orderByComparator);
610            }
611    
612            /**
613            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
614            *
615            * @param resourcePrimKey the resource prim key
616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
617            * @return the last matching journal article
618            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
619            * @throws SystemException if a system exception occurred
620            */
621            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
622                    long resourcePrimKey,
623                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
624                    throws com.liferay.portal.kernel.exception.SystemException,
625                            com.liferay.portlet.journal.NoSuchArticleException {
626                    return getPersistence()
627                                       .findByResourcePrimKey_Last(resourcePrimKey,
628                            orderByComparator);
629            }
630    
631            /**
632            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
633            *
634            * @param resourcePrimKey the resource prim key
635            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
636            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
637            * @throws SystemException if a system exception occurred
638            */
639            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last(
640                    long resourcePrimKey,
641                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
642                    throws com.liferay.portal.kernel.exception.SystemException {
643                    return getPersistence()
644                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
645                            orderByComparator);
646            }
647    
648            /**
649            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
650            *
651            * @param id the primary key of the current journal article
652            * @param resourcePrimKey the resource prim key
653            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
654            * @return the previous, current, and next journal article
655            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
656            * @throws SystemException if a system exception occurred
657            */
658            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
659                    long id, long resourcePrimKey,
660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
661                    throws com.liferay.portal.kernel.exception.SystemException,
662                            com.liferay.portlet.journal.NoSuchArticleException {
663                    return getPersistence()
664                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
665                            orderByComparator);
666            }
667    
668            /**
669            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
670            *
671            * @param resourcePrimKey the resource prim key
672            * @throws SystemException if a system exception occurred
673            */
674            public static void removeByResourcePrimKey(long resourcePrimKey)
675                    throws com.liferay.portal.kernel.exception.SystemException {
676                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
677            }
678    
679            /**
680            * Returns the number of journal articles where resourcePrimKey = &#63;.
681            *
682            * @param resourcePrimKey the resource prim key
683            * @return the number of matching journal articles
684            * @throws SystemException if a system exception occurred
685            */
686            public static int countByResourcePrimKey(long resourcePrimKey)
687                    throws com.liferay.portal.kernel.exception.SystemException {
688                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
689            }
690    
691            /**
692            * Returns all the journal articles where groupId = &#63;.
693            *
694            * @param groupId the group ID
695            * @return the matching journal articles
696            * @throws SystemException if a system exception occurred
697            */
698            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
699                    long groupId)
700                    throws com.liferay.portal.kernel.exception.SystemException {
701                    return getPersistence().findByGroupId(groupId);
702            }
703    
704            /**
705            * Returns a range of all the journal articles where groupId = &#63;.
706            *
707            * <p>
708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
709            * </p>
710            *
711            * @param groupId the group ID
712            * @param start the lower bound of the range of journal articles
713            * @param end the upper bound of the range of journal articles (not inclusive)
714            * @return the range of matching journal articles
715            * @throws SystemException if a system exception occurred
716            */
717            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
718                    long groupId, int start, int end)
719                    throws com.liferay.portal.kernel.exception.SystemException {
720                    return getPersistence().findByGroupId(groupId, start, end);
721            }
722    
723            /**
724            * Returns an ordered range of all the journal articles where groupId = &#63;.
725            *
726            * <p>
727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
728            * </p>
729            *
730            * @param groupId the group ID
731            * @param start the lower bound of the range of journal articles
732            * @param end the upper bound of the range of journal articles (not inclusive)
733            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
734            * @return the ordered range of matching journal articles
735            * @throws SystemException if a system exception occurred
736            */
737            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
738                    long groupId, int start, int end,
739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
740                    throws com.liferay.portal.kernel.exception.SystemException {
741                    return getPersistence()
742                                       .findByGroupId(groupId, start, end, orderByComparator);
743            }
744    
745            /**
746            * Returns the first journal article in the ordered set where groupId = &#63;.
747            *
748            * @param groupId the group ID
749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
750            * @return the first matching journal article
751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
752            * @throws SystemException if a system exception occurred
753            */
754            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
755                    long groupId,
756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
757                    throws com.liferay.portal.kernel.exception.SystemException,
758                            com.liferay.portlet.journal.NoSuchArticleException {
759                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
760            }
761    
762            /**
763            * Returns the first journal article in the ordered set where groupId = &#63;.
764            *
765            * @param groupId the group ID
766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
767            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
768            * @throws SystemException if a system exception occurred
769            */
770            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First(
771                    long groupId,
772                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
773                    throws com.liferay.portal.kernel.exception.SystemException {
774                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
775            }
776    
777            /**
778            * Returns the last journal article in the ordered set where groupId = &#63;.
779            *
780            * @param groupId the group ID
781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
782            * @return the last matching journal article
783            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
784            * @throws SystemException if a system exception occurred
785            */
786            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
787                    long groupId,
788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
789                    throws com.liferay.portal.kernel.exception.SystemException,
790                            com.liferay.portlet.journal.NoSuchArticleException {
791                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
792            }
793    
794            /**
795            * Returns the last journal article in the ordered set where groupId = &#63;.
796            *
797            * @param groupId the group ID
798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
799            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
800            * @throws SystemException if a system exception occurred
801            */
802            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last(
803                    long groupId,
804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
805                    throws com.liferay.portal.kernel.exception.SystemException {
806                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
807            }
808    
809            /**
810            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
811            *
812            * @param id the primary key of the current journal article
813            * @param groupId the group ID
814            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
815            * @return the previous, current, and next journal article
816            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
817            * @throws SystemException if a system exception occurred
818            */
819            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
820                    long id, long groupId,
821                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
822                    throws com.liferay.portal.kernel.exception.SystemException,
823                            com.liferay.portlet.journal.NoSuchArticleException {
824                    return getPersistence()
825                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
826            }
827    
828            /**
829            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
830            *
831            * @param groupId the group ID
832            * @return the matching journal articles that the user has permission to view
833            * @throws SystemException if a system exception occurred
834            */
835            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
836                    long groupId)
837                    throws com.liferay.portal.kernel.exception.SystemException {
838                    return getPersistence().filterFindByGroupId(groupId);
839            }
840    
841            /**
842            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
843            *
844            * <p>
845            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
846            * </p>
847            *
848            * @param groupId the group ID
849            * @param start the lower bound of the range of journal articles
850            * @param end the upper bound of the range of journal articles (not inclusive)
851            * @return the range of matching journal articles that the user has permission to view
852            * @throws SystemException if a system exception occurred
853            */
854            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
855                    long groupId, int start, int end)
856                    throws com.liferay.portal.kernel.exception.SystemException {
857                    return getPersistence().filterFindByGroupId(groupId, start, end);
858            }
859    
860            /**
861            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
862            *
863            * <p>
864            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
865            * </p>
866            *
867            * @param groupId the group ID
868            * @param start the lower bound of the range of journal articles
869            * @param end the upper bound of the range of journal articles (not inclusive)
870            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
871            * @return the ordered range of matching journal articles that the user has permission to view
872            * @throws SystemException if a system exception occurred
873            */
874            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
875                    long groupId, int start, int end,
876                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
877                    throws com.liferay.portal.kernel.exception.SystemException {
878                    return getPersistence()
879                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
880            }
881    
882            /**
883            * 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;.
884            *
885            * @param id the primary key of the current journal article
886            * @param groupId the group ID
887            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
888            * @return the previous, current, and next journal article
889            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
890            * @throws SystemException if a system exception occurred
891            */
892            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
893                    long id, long groupId,
894                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
895                    throws com.liferay.portal.kernel.exception.SystemException,
896                            com.liferay.portlet.journal.NoSuchArticleException {
897                    return getPersistence()
898                                       .filterFindByGroupId_PrevAndNext(id, groupId,
899                            orderByComparator);
900            }
901    
902            /**
903            * Removes all the journal articles where groupId = &#63; from the database.
904            *
905            * @param groupId the group ID
906            * @throws SystemException if a system exception occurred
907            */
908            public static void removeByGroupId(long groupId)
909                    throws com.liferay.portal.kernel.exception.SystemException {
910                    getPersistence().removeByGroupId(groupId);
911            }
912    
913            /**
914            * Returns the number of journal articles where groupId = &#63;.
915            *
916            * @param groupId the group ID
917            * @return the number of matching journal articles
918            * @throws SystemException if a system exception occurred
919            */
920            public static int countByGroupId(long groupId)
921                    throws com.liferay.portal.kernel.exception.SystemException {
922                    return getPersistence().countByGroupId(groupId);
923            }
924    
925            /**
926            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
927            *
928            * @param groupId the group ID
929            * @return the number of matching journal articles that the user has permission to view
930            * @throws SystemException if a system exception occurred
931            */
932            public static int filterCountByGroupId(long groupId)
933                    throws com.liferay.portal.kernel.exception.SystemException {
934                    return getPersistence().filterCountByGroupId(groupId);
935            }
936    
937            /**
938            * Returns all the journal articles where companyId = &#63;.
939            *
940            * @param companyId the company ID
941            * @return the matching journal articles
942            * @throws SystemException if a system exception occurred
943            */
944            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
945                    long companyId)
946                    throws com.liferay.portal.kernel.exception.SystemException {
947                    return getPersistence().findByCompanyId(companyId);
948            }
949    
950            /**
951            * Returns a range of all the journal articles where companyId = &#63;.
952            *
953            * <p>
954            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
955            * </p>
956            *
957            * @param companyId the company ID
958            * @param start the lower bound of the range of journal articles
959            * @param end the upper bound of the range of journal articles (not inclusive)
960            * @return the range of matching journal articles
961            * @throws SystemException if a system exception occurred
962            */
963            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
964                    long companyId, int start, int end)
965                    throws com.liferay.portal.kernel.exception.SystemException {
966                    return getPersistence().findByCompanyId(companyId, start, end);
967            }
968    
969            /**
970            * Returns an ordered range of all the journal articles where companyId = &#63;.
971            *
972            * <p>
973            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
974            * </p>
975            *
976            * @param companyId the company ID
977            * @param start the lower bound of the range of journal articles
978            * @param end the upper bound of the range of journal articles (not inclusive)
979            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
980            * @return the ordered range of matching journal articles
981            * @throws SystemException if a system exception occurred
982            */
983            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
984                    long companyId, int start, int end,
985                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
986                    throws com.liferay.portal.kernel.exception.SystemException {
987                    return getPersistence()
988                                       .findByCompanyId(companyId, start, end, orderByComparator);
989            }
990    
991            /**
992            * Returns the first journal article in the ordered set where companyId = &#63;.
993            *
994            * @param companyId the company ID
995            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
996            * @return the first matching journal article
997            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
998            * @throws SystemException if a system exception occurred
999            */
1000            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
1001                    long companyId,
1002                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1003                    throws com.liferay.portal.kernel.exception.SystemException,
1004                            com.liferay.portlet.journal.NoSuchArticleException {
1005                    return getPersistence()
1006                                       .findByCompanyId_First(companyId, orderByComparator);
1007            }
1008    
1009            /**
1010            * Returns the first journal article in the ordered set where companyId = &#63;.
1011            *
1012            * @param companyId the company ID
1013            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1014            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1015            * @throws SystemException if a system exception occurred
1016            */
1017            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First(
1018                    long companyId,
1019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1020                    throws com.liferay.portal.kernel.exception.SystemException {
1021                    return getPersistence()
1022                                       .fetchByCompanyId_First(companyId, orderByComparator);
1023            }
1024    
1025            /**
1026            * Returns the last journal article in the ordered set where companyId = &#63;.
1027            *
1028            * @param companyId the company ID
1029            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1030            * @return the last matching journal article
1031            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1032            * @throws SystemException if a system exception occurred
1033            */
1034            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
1035                    long companyId,
1036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1037                    throws com.liferay.portal.kernel.exception.SystemException,
1038                            com.liferay.portlet.journal.NoSuchArticleException {
1039                    return getPersistence()
1040                                       .findByCompanyId_Last(companyId, orderByComparator);
1041            }
1042    
1043            /**
1044            * Returns the last journal article in the ordered set where companyId = &#63;.
1045            *
1046            * @param companyId the company ID
1047            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1048            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1049            * @throws SystemException if a system exception occurred
1050            */
1051            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last(
1052                    long companyId,
1053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1054                    throws com.liferay.portal.kernel.exception.SystemException {
1055                    return getPersistence()
1056                                       .fetchByCompanyId_Last(companyId, orderByComparator);
1057            }
1058    
1059            /**
1060            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
1061            *
1062            * @param id the primary key of the current journal article
1063            * @param companyId the company ID
1064            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1065            * @return the previous, current, and next journal article
1066            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1067            * @throws SystemException if a system exception occurred
1068            */
1069            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
1070                    long id, long companyId,
1071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1072                    throws com.liferay.portal.kernel.exception.SystemException,
1073                            com.liferay.portlet.journal.NoSuchArticleException {
1074                    return getPersistence()
1075                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
1076            }
1077    
1078            /**
1079            * Removes all the journal articles where companyId = &#63; from the database.
1080            *
1081            * @param companyId the company ID
1082            * @throws SystemException if a system exception occurred
1083            */
1084            public static void removeByCompanyId(long companyId)
1085                    throws com.liferay.portal.kernel.exception.SystemException {
1086                    getPersistence().removeByCompanyId(companyId);
1087            }
1088    
1089            /**
1090            * Returns the number of journal articles where companyId = &#63;.
1091            *
1092            * @param companyId the company ID
1093            * @return the number of matching journal articles
1094            * @throws SystemException if a system exception occurred
1095            */
1096            public static int countByCompanyId(long companyId)
1097                    throws com.liferay.portal.kernel.exception.SystemException {
1098                    return getPersistence().countByCompanyId(companyId);
1099            }
1100    
1101            /**
1102            * Returns all the journal articles where structureId = &#63;.
1103            *
1104            * @param structureId the structure ID
1105            * @return the matching journal articles
1106            * @throws SystemException if a system exception occurred
1107            */
1108            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1109                    java.lang.String structureId)
1110                    throws com.liferay.portal.kernel.exception.SystemException {
1111                    return getPersistence().findByStructureId(structureId);
1112            }
1113    
1114            /**
1115            * Returns a range of all the journal articles where structureId = &#63;.
1116            *
1117            * <p>
1118            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1119            * </p>
1120            *
1121            * @param structureId the structure ID
1122            * @param start the lower bound of the range of journal articles
1123            * @param end the upper bound of the range of journal articles (not inclusive)
1124            * @return the range of matching journal articles
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1128                    java.lang.String structureId, int start, int end)
1129                    throws com.liferay.portal.kernel.exception.SystemException {
1130                    return getPersistence().findByStructureId(structureId, start, end);
1131            }
1132    
1133            /**
1134            * Returns an ordered range of all the journal articles where structureId = &#63;.
1135            *
1136            * <p>
1137            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1138            * </p>
1139            *
1140            * @param structureId the structure ID
1141            * @param start the lower bound of the range of journal articles
1142            * @param end the upper bound of the range of journal articles (not inclusive)
1143            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1144            * @return the ordered range of matching journal articles
1145            * @throws SystemException if a system exception occurred
1146            */
1147            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1148                    java.lang.String structureId, int start, int end,
1149                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1150                    throws com.liferay.portal.kernel.exception.SystemException {
1151                    return getPersistence()
1152                                       .findByStructureId(structureId, start, end, orderByComparator);
1153            }
1154    
1155            /**
1156            * Returns the first journal article in the ordered set where structureId = &#63;.
1157            *
1158            * @param structureId the structure ID
1159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1160            * @return the first matching journal article
1161            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1162            * @throws SystemException if a system exception occurred
1163            */
1164            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
1165                    java.lang.String structureId,
1166                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1167                    throws com.liferay.portal.kernel.exception.SystemException,
1168                            com.liferay.portlet.journal.NoSuchArticleException {
1169                    return getPersistence()
1170                                       .findByStructureId_First(structureId, orderByComparator);
1171            }
1172    
1173            /**
1174            * Returns the first journal article in the ordered set where structureId = &#63;.
1175            *
1176            * @param structureId the structure ID
1177            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1178            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1179            * @throws SystemException if a system exception occurred
1180            */
1181            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First(
1182                    java.lang.String structureId,
1183                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1184                    throws com.liferay.portal.kernel.exception.SystemException {
1185                    return getPersistence()
1186                                       .fetchByStructureId_First(structureId, orderByComparator);
1187            }
1188    
1189            /**
1190            * Returns the last journal article in the ordered set where structureId = &#63;.
1191            *
1192            * @param structureId the structure ID
1193            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1194            * @return the last matching journal article
1195            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1196            * @throws SystemException if a system exception occurred
1197            */
1198            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
1199                    java.lang.String structureId,
1200                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1201                    throws com.liferay.portal.kernel.exception.SystemException,
1202                            com.liferay.portlet.journal.NoSuchArticleException {
1203                    return getPersistence()
1204                                       .findByStructureId_Last(structureId, orderByComparator);
1205            }
1206    
1207            /**
1208            * Returns the last journal article in the ordered set where structureId = &#63;.
1209            *
1210            * @param structureId the structure ID
1211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1212            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1213            * @throws SystemException if a system exception occurred
1214            */
1215            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last(
1216                    java.lang.String structureId,
1217                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1218                    throws com.liferay.portal.kernel.exception.SystemException {
1219                    return getPersistence()
1220                                       .fetchByStructureId_Last(structureId, orderByComparator);
1221            }
1222    
1223            /**
1224            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
1225            *
1226            * @param id the primary key of the current journal article
1227            * @param structureId the structure ID
1228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1229            * @return the previous, current, and next journal article
1230            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1231            * @throws SystemException if a system exception occurred
1232            */
1233            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
1234                    long id, java.lang.String structureId,
1235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1236                    throws com.liferay.portal.kernel.exception.SystemException,
1237                            com.liferay.portlet.journal.NoSuchArticleException {
1238                    return getPersistence()
1239                                       .findByStructureId_PrevAndNext(id, structureId,
1240                            orderByComparator);
1241            }
1242    
1243            /**
1244            * Removes all the journal articles where structureId = &#63; from the database.
1245            *
1246            * @param structureId the structure ID
1247            * @throws SystemException if a system exception occurred
1248            */
1249            public static void removeByStructureId(java.lang.String structureId)
1250                    throws com.liferay.portal.kernel.exception.SystemException {
1251                    getPersistence().removeByStructureId(structureId);
1252            }
1253    
1254            /**
1255            * Returns the number of journal articles where structureId = &#63;.
1256            *
1257            * @param structureId the structure ID
1258            * @return the number of matching journal articles
1259            * @throws SystemException if a system exception occurred
1260            */
1261            public static int countByStructureId(java.lang.String structureId)
1262                    throws com.liferay.portal.kernel.exception.SystemException {
1263                    return getPersistence().countByStructureId(structureId);
1264            }
1265    
1266            /**
1267            * Returns all the journal articles where templateId = &#63;.
1268            *
1269            * @param templateId the template ID
1270            * @return the matching journal articles
1271            * @throws SystemException if a system exception occurred
1272            */
1273            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1274                    java.lang.String templateId)
1275                    throws com.liferay.portal.kernel.exception.SystemException {
1276                    return getPersistence().findByTemplateId(templateId);
1277            }
1278    
1279            /**
1280            * Returns a range of all the journal articles where templateId = &#63;.
1281            *
1282            * <p>
1283            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1284            * </p>
1285            *
1286            * @param templateId the template ID
1287            * @param start the lower bound of the range of journal articles
1288            * @param end the upper bound of the range of journal articles (not inclusive)
1289            * @return the range of matching journal articles
1290            * @throws SystemException if a system exception occurred
1291            */
1292            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1293                    java.lang.String templateId, int start, int end)
1294                    throws com.liferay.portal.kernel.exception.SystemException {
1295                    return getPersistence().findByTemplateId(templateId, start, end);
1296            }
1297    
1298            /**
1299            * Returns an ordered range of all the journal articles where templateId = &#63;.
1300            *
1301            * <p>
1302            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1303            * </p>
1304            *
1305            * @param templateId the template ID
1306            * @param start the lower bound of the range of journal articles
1307            * @param end the upper bound of the range of journal articles (not inclusive)
1308            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1309            * @return the ordered range of matching journal articles
1310            * @throws SystemException if a system exception occurred
1311            */
1312            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1313                    java.lang.String templateId, int start, int end,
1314                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1315                    throws com.liferay.portal.kernel.exception.SystemException {
1316                    return getPersistence()
1317                                       .findByTemplateId(templateId, start, end, orderByComparator);
1318            }
1319    
1320            /**
1321            * Returns the first journal article in the ordered set where templateId = &#63;.
1322            *
1323            * @param templateId the template ID
1324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1325            * @return the first matching journal article
1326            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1327            * @throws SystemException if a system exception occurred
1328            */
1329            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1330                    java.lang.String templateId,
1331                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1332                    throws com.liferay.portal.kernel.exception.SystemException,
1333                            com.liferay.portlet.journal.NoSuchArticleException {
1334                    return getPersistence()
1335                                       .findByTemplateId_First(templateId, orderByComparator);
1336            }
1337    
1338            /**
1339            * Returns the first journal article in the ordered set where templateId = &#63;.
1340            *
1341            * @param templateId the template ID
1342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1343            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1344            * @throws SystemException if a system exception occurred
1345            */
1346            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1347                    java.lang.String templateId,
1348                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1349                    throws com.liferay.portal.kernel.exception.SystemException {
1350                    return getPersistence()
1351                                       .fetchByTemplateId_First(templateId, orderByComparator);
1352            }
1353    
1354            /**
1355            * Returns the last journal article in the ordered set where templateId = &#63;.
1356            *
1357            * @param templateId the template ID
1358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1359            * @return the last matching journal article
1360            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1364                    java.lang.String templateId,
1365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1366                    throws com.liferay.portal.kernel.exception.SystemException,
1367                            com.liferay.portlet.journal.NoSuchArticleException {
1368                    return getPersistence()
1369                                       .findByTemplateId_Last(templateId, orderByComparator);
1370            }
1371    
1372            /**
1373            * Returns the last journal article in the ordered set where templateId = &#63;.
1374            *
1375            * @param templateId the template ID
1376            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1377            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1378            * @throws SystemException if a system exception occurred
1379            */
1380            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1381                    java.lang.String templateId,
1382                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1383                    throws com.liferay.portal.kernel.exception.SystemException {
1384                    return getPersistence()
1385                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1386            }
1387    
1388            /**
1389            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1390            *
1391            * @param id the primary key of the current journal article
1392            * @param templateId the template ID
1393            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1394            * @return the previous, current, and next journal article
1395            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1396            * @throws SystemException if a system exception occurred
1397            */
1398            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1399                    long id, java.lang.String templateId,
1400                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1401                    throws com.liferay.portal.kernel.exception.SystemException,
1402                            com.liferay.portlet.journal.NoSuchArticleException {
1403                    return getPersistence()
1404                                       .findByTemplateId_PrevAndNext(id, templateId,
1405                            orderByComparator);
1406            }
1407    
1408            /**
1409            * Removes all the journal articles where templateId = &#63; from the database.
1410            *
1411            * @param templateId the template ID
1412            * @throws SystemException if a system exception occurred
1413            */
1414            public static void removeByTemplateId(java.lang.String templateId)
1415                    throws com.liferay.portal.kernel.exception.SystemException {
1416                    getPersistence().removeByTemplateId(templateId);
1417            }
1418    
1419            /**
1420            * Returns the number of journal articles where templateId = &#63;.
1421            *
1422            * @param templateId the template ID
1423            * @return the number of matching journal articles
1424            * @throws SystemException if a system exception occurred
1425            */
1426            public static int countByTemplateId(java.lang.String templateId)
1427                    throws com.liferay.portal.kernel.exception.SystemException {
1428                    return getPersistence().countByTemplateId(templateId);
1429            }
1430    
1431            /**
1432            * Returns all the journal articles where layoutUuid = &#63;.
1433            *
1434            * @param layoutUuid the layout uuid
1435            * @return the matching journal articles
1436            * @throws SystemException if a system exception occurred
1437            */
1438            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1439                    java.lang.String layoutUuid)
1440                    throws com.liferay.portal.kernel.exception.SystemException {
1441                    return getPersistence().findByLayoutUuid(layoutUuid);
1442            }
1443    
1444            /**
1445            * Returns a range of all the journal articles where layoutUuid = &#63;.
1446            *
1447            * <p>
1448            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1449            * </p>
1450            *
1451            * @param layoutUuid the layout uuid
1452            * @param start the lower bound of the range of journal articles
1453            * @param end the upper bound of the range of journal articles (not inclusive)
1454            * @return the range of matching journal articles
1455            * @throws SystemException if a system exception occurred
1456            */
1457            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1458                    java.lang.String layoutUuid, int start, int end)
1459                    throws com.liferay.portal.kernel.exception.SystemException {
1460                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1461            }
1462    
1463            /**
1464            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1465            *
1466            * <p>
1467            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1468            * </p>
1469            *
1470            * @param layoutUuid the layout uuid
1471            * @param start the lower bound of the range of journal articles
1472            * @param end the upper bound of the range of journal articles (not inclusive)
1473            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1474            * @return the ordered range of matching journal articles
1475            * @throws SystemException if a system exception occurred
1476            */
1477            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1478                    java.lang.String layoutUuid, int start, int end,
1479                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1480                    throws com.liferay.portal.kernel.exception.SystemException {
1481                    return getPersistence()
1482                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1483            }
1484    
1485            /**
1486            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1487            *
1488            * @param layoutUuid the layout uuid
1489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1490            * @return the first matching journal article
1491            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1492            * @throws SystemException if a system exception occurred
1493            */
1494            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First(
1495                    java.lang.String layoutUuid,
1496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1497                    throws com.liferay.portal.kernel.exception.SystemException,
1498                            com.liferay.portlet.journal.NoSuchArticleException {
1499                    return getPersistence()
1500                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1501            }
1502    
1503            /**
1504            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1505            *
1506            * @param layoutUuid the layout uuid
1507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1508            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1509            * @throws SystemException if a system exception occurred
1510            */
1511            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First(
1512                    java.lang.String layoutUuid,
1513                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1514                    throws com.liferay.portal.kernel.exception.SystemException {
1515                    return getPersistence()
1516                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1517            }
1518    
1519            /**
1520            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1521            *
1522            * @param layoutUuid the layout uuid
1523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1524            * @return the last matching journal article
1525            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1526            * @throws SystemException if a system exception occurred
1527            */
1528            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last(
1529                    java.lang.String layoutUuid,
1530                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1531                    throws com.liferay.portal.kernel.exception.SystemException,
1532                            com.liferay.portlet.journal.NoSuchArticleException {
1533                    return getPersistence()
1534                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1535            }
1536    
1537            /**
1538            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1539            *
1540            * @param layoutUuid the layout uuid
1541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1542            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1543            * @throws SystemException if a system exception occurred
1544            */
1545            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last(
1546                    java.lang.String layoutUuid,
1547                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1548                    throws com.liferay.portal.kernel.exception.SystemException {
1549                    return getPersistence()
1550                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1551            }
1552    
1553            /**
1554            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1555            *
1556            * @param id the primary key of the current journal article
1557            * @param layoutUuid the layout uuid
1558            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1559            * @return the previous, current, and next journal article
1560            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1561            * @throws SystemException if a system exception occurred
1562            */
1563            public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext(
1564                    long id, java.lang.String layoutUuid,
1565                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1566                    throws com.liferay.portal.kernel.exception.SystemException,
1567                            com.liferay.portlet.journal.NoSuchArticleException {
1568                    return getPersistence()
1569                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1570                            orderByComparator);
1571            }
1572    
1573            /**
1574            * Removes all the journal articles where layoutUuid = &#63; from the database.
1575            *
1576            * @param layoutUuid the layout uuid
1577            * @throws SystemException if a system exception occurred
1578            */
1579            public static void removeByLayoutUuid(java.lang.String layoutUuid)
1580                    throws com.liferay.portal.kernel.exception.SystemException {
1581                    getPersistence().removeByLayoutUuid(layoutUuid);
1582            }
1583    
1584            /**
1585            * Returns the number of journal articles where layoutUuid = &#63;.
1586            *
1587            * @param layoutUuid the layout uuid
1588            * @return the number of matching journal articles
1589            * @throws SystemException if a system exception occurred
1590            */
1591            public static int countByLayoutUuid(java.lang.String layoutUuid)
1592                    throws com.liferay.portal.kernel.exception.SystemException {
1593                    return getPersistence().countByLayoutUuid(layoutUuid);
1594            }
1595    
1596            /**
1597            * Returns all the journal articles where smallImageId = &#63;.
1598            *
1599            * @param smallImageId the small image ID
1600            * @return the matching journal articles
1601            * @throws SystemException if a system exception occurred
1602            */
1603            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1604                    long smallImageId)
1605                    throws com.liferay.portal.kernel.exception.SystemException {
1606                    return getPersistence().findBySmallImageId(smallImageId);
1607            }
1608    
1609            /**
1610            * Returns a range of all the journal articles where smallImageId = &#63;.
1611            *
1612            * <p>
1613            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1614            * </p>
1615            *
1616            * @param smallImageId the small image ID
1617            * @param start the lower bound of the range of journal articles
1618            * @param end the upper bound of the range of journal articles (not inclusive)
1619            * @return the range of matching journal articles
1620            * @throws SystemException if a system exception occurred
1621            */
1622            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1623                    long smallImageId, int start, int end)
1624                    throws com.liferay.portal.kernel.exception.SystemException {
1625                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1626            }
1627    
1628            /**
1629            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1630            *
1631            * <p>
1632            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1633            * </p>
1634            *
1635            * @param smallImageId the small image ID
1636            * @param start the lower bound of the range of journal articles
1637            * @param end the upper bound of the range of journal articles (not inclusive)
1638            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1639            * @return the ordered range of matching journal articles
1640            * @throws SystemException if a system exception occurred
1641            */
1642            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1643                    long smallImageId, int start, int end,
1644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1645                    throws com.liferay.portal.kernel.exception.SystemException {
1646                    return getPersistence()
1647                                       .findBySmallImageId(smallImageId, start, end,
1648                            orderByComparator);
1649            }
1650    
1651            /**
1652            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1653            *
1654            * @param smallImageId the small image ID
1655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1656            * @return the first matching journal article
1657            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1658            * @throws SystemException if a system exception occurred
1659            */
1660            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1661                    long smallImageId,
1662                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1663                    throws com.liferay.portal.kernel.exception.SystemException,
1664                            com.liferay.portlet.journal.NoSuchArticleException {
1665                    return getPersistence()
1666                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1667            }
1668    
1669            /**
1670            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1671            *
1672            * @param smallImageId the small image ID
1673            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1674            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1675            * @throws SystemException if a system exception occurred
1676            */
1677            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1678                    long smallImageId,
1679                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1680                    throws com.liferay.portal.kernel.exception.SystemException {
1681                    return getPersistence()
1682                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1683            }
1684    
1685            /**
1686            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1687            *
1688            * @param smallImageId the small image ID
1689            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1690            * @return the last matching journal article
1691            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1692            * @throws SystemException if a system exception occurred
1693            */
1694            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1695                    long smallImageId,
1696                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1697                    throws com.liferay.portal.kernel.exception.SystemException,
1698                            com.liferay.portlet.journal.NoSuchArticleException {
1699                    return getPersistence()
1700                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1701            }
1702    
1703            /**
1704            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1705            *
1706            * @param smallImageId the small image ID
1707            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1708            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1709            * @throws SystemException if a system exception occurred
1710            */
1711            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1712                    long smallImageId,
1713                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1714                    throws com.liferay.portal.kernel.exception.SystemException {
1715                    return getPersistence()
1716                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1717            }
1718    
1719            /**
1720            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1721            *
1722            * @param id the primary key of the current journal article
1723            * @param smallImageId the small image ID
1724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1725            * @return the previous, current, and next journal article
1726            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1727            * @throws SystemException if a system exception occurred
1728            */
1729            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1730                    long id, long smallImageId,
1731                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1732                    throws com.liferay.portal.kernel.exception.SystemException,
1733                            com.liferay.portlet.journal.NoSuchArticleException {
1734                    return getPersistence()
1735                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1736                            orderByComparator);
1737            }
1738    
1739            /**
1740            * Removes all the journal articles where smallImageId = &#63; from the database.
1741            *
1742            * @param smallImageId the small image ID
1743            * @throws SystemException if a system exception occurred
1744            */
1745            public static void removeBySmallImageId(long smallImageId)
1746                    throws com.liferay.portal.kernel.exception.SystemException {
1747                    getPersistence().removeBySmallImageId(smallImageId);
1748            }
1749    
1750            /**
1751            * Returns the number of journal articles where smallImageId = &#63;.
1752            *
1753            * @param smallImageId the small image ID
1754            * @return the number of matching journal articles
1755            * @throws SystemException if a system exception occurred
1756            */
1757            public static int countBySmallImageId(long smallImageId)
1758                    throws com.liferay.portal.kernel.exception.SystemException {
1759                    return getPersistence().countBySmallImageId(smallImageId);
1760            }
1761    
1762            /**
1763            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1764            *
1765            * @param resourcePrimKey the resource prim key
1766            * @param status the status
1767            * @return the matching journal articles
1768            * @throws SystemException if a system exception occurred
1769            */
1770            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1771                    long resourcePrimKey, int status)
1772                    throws com.liferay.portal.kernel.exception.SystemException {
1773                    return getPersistence().findByR_ST(resourcePrimKey, status);
1774            }
1775    
1776            /**
1777            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1778            *
1779            * <p>
1780            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1781            * </p>
1782            *
1783            * @param resourcePrimKey the resource prim key
1784            * @param status the status
1785            * @param start the lower bound of the range of journal articles
1786            * @param end the upper bound of the range of journal articles (not inclusive)
1787            * @return the range of matching journal articles
1788            * @throws SystemException if a system exception occurred
1789            */
1790            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1791                    long resourcePrimKey, int status, int start, int end)
1792                    throws com.liferay.portal.kernel.exception.SystemException {
1793                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1794            }
1795    
1796            /**
1797            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1798            *
1799            * <p>
1800            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1801            * </p>
1802            *
1803            * @param resourcePrimKey the resource prim key
1804            * @param status the status
1805            * @param start the lower bound of the range of journal articles
1806            * @param end the upper bound of the range of journal articles (not inclusive)
1807            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1808            * @return the ordered range of matching journal articles
1809            * @throws SystemException if a system exception occurred
1810            */
1811            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1812                    long resourcePrimKey, int status, int start, int end,
1813                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1814                    throws com.liferay.portal.kernel.exception.SystemException {
1815                    return getPersistence()
1816                                       .findByR_ST(resourcePrimKey, status, start, end,
1817                            orderByComparator);
1818            }
1819    
1820            /**
1821            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1822            *
1823            * @param resourcePrimKey the resource prim key
1824            * @param status the status
1825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1826            * @return the first matching journal article
1827            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1828            * @throws SystemException if a system exception occurred
1829            */
1830            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1831                    long resourcePrimKey, int status,
1832                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1833                    throws com.liferay.portal.kernel.exception.SystemException,
1834                            com.liferay.portlet.journal.NoSuchArticleException {
1835                    return getPersistence()
1836                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1837            }
1838    
1839            /**
1840            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1841            *
1842            * @param resourcePrimKey the resource prim key
1843            * @param status the status
1844            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1845            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1846            * @throws SystemException if a system exception occurred
1847            */
1848            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
1849                    long resourcePrimKey, int status,
1850                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1851                    throws com.liferay.portal.kernel.exception.SystemException {
1852                    return getPersistence()
1853                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
1854            }
1855    
1856            /**
1857            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1858            *
1859            * @param resourcePrimKey the resource prim key
1860            * @param status the status
1861            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1862            * @return the last matching journal article
1863            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1864            * @throws SystemException if a system exception occurred
1865            */
1866            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1867                    long resourcePrimKey, int status,
1868                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1869                    throws com.liferay.portal.kernel.exception.SystemException,
1870                            com.liferay.portlet.journal.NoSuchArticleException {
1871                    return getPersistence()
1872                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1873            }
1874    
1875            /**
1876            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1877            *
1878            * @param resourcePrimKey the resource prim key
1879            * @param status the status
1880            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1881            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1882            * @throws SystemException if a system exception occurred
1883            */
1884            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
1885                    long resourcePrimKey, int status,
1886                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1887                    throws com.liferay.portal.kernel.exception.SystemException {
1888                    return getPersistence()
1889                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
1890            }
1891    
1892            /**
1893            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1894            *
1895            * @param id the primary key of the current journal article
1896            * @param resourcePrimKey the resource prim key
1897            * @param status the status
1898            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1899            * @return the previous, current, and next journal article
1900            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1901            * @throws SystemException if a system exception occurred
1902            */
1903            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1904                    long id, long resourcePrimKey, int status,
1905                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1906                    throws com.liferay.portal.kernel.exception.SystemException,
1907                            com.liferay.portlet.journal.NoSuchArticleException {
1908                    return getPersistence()
1909                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1910                            orderByComparator);
1911            }
1912    
1913            /**
1914            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
1915            *
1916            * @param resourcePrimKey the resource prim key
1917            * @param status the status
1918            * @throws SystemException if a system exception occurred
1919            */
1920            public static void removeByR_ST(long resourcePrimKey, int status)
1921                    throws com.liferay.portal.kernel.exception.SystemException {
1922                    getPersistence().removeByR_ST(resourcePrimKey, status);
1923            }
1924    
1925            /**
1926            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
1927            *
1928            * @param resourcePrimKey the resource prim key
1929            * @param status the status
1930            * @return the number of matching journal articles
1931            * @throws SystemException if a system exception occurred
1932            */
1933            public static int countByR_ST(long resourcePrimKey, int status)
1934                    throws com.liferay.portal.kernel.exception.SystemException {
1935                    return getPersistence().countByR_ST(resourcePrimKey, status);
1936            }
1937    
1938            /**
1939            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
1940            *
1941            * @param groupId the group ID
1942            * @param userId the user ID
1943            * @return the matching journal articles
1944            * @throws SystemException if a system exception occurred
1945            */
1946            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
1947                    long groupId, long userId)
1948                    throws com.liferay.portal.kernel.exception.SystemException {
1949                    return getPersistence().findByG_U(groupId, userId);
1950            }
1951    
1952            /**
1953            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
1954            *
1955            * <p>
1956            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1957            * </p>
1958            *
1959            * @param groupId the group ID
1960            * @param userId the user ID
1961            * @param start the lower bound of the range of journal articles
1962            * @param end the upper bound of the range of journal articles (not inclusive)
1963            * @return the range of matching journal articles
1964            * @throws SystemException if a system exception occurred
1965            */
1966            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
1967                    long groupId, long userId, int start, int end)
1968                    throws com.liferay.portal.kernel.exception.SystemException {
1969                    return getPersistence().findByG_U(groupId, userId, start, end);
1970            }
1971    
1972            /**
1973            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
1974            *
1975            * <p>
1976            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1977            * </p>
1978            *
1979            * @param groupId the group ID
1980            * @param userId the user ID
1981            * @param start the lower bound of the range of journal articles
1982            * @param end the upper bound of the range of journal articles (not inclusive)
1983            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1984            * @return the ordered range of matching journal articles
1985            * @throws SystemException if a system exception occurred
1986            */
1987            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
1988                    long groupId, long userId, int start, int end,
1989                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1990                    throws com.liferay.portal.kernel.exception.SystemException {
1991                    return getPersistence()
1992                                       .findByG_U(groupId, userId, start, end, orderByComparator);
1993            }
1994    
1995            /**
1996            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
1997            *
1998            * @param groupId the group ID
1999            * @param userId the user ID
2000            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2001            * @return the first matching journal article
2002            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2003            * @throws SystemException if a system exception occurred
2004            */
2005            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First(
2006                    long groupId, long userId,
2007                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2008                    throws com.liferay.portal.kernel.exception.SystemException,
2009                            com.liferay.portlet.journal.NoSuchArticleException {
2010                    return getPersistence()
2011                                       .findByG_U_First(groupId, userId, orderByComparator);
2012            }
2013    
2014            /**
2015            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2016            *
2017            * @param groupId the group ID
2018            * @param userId the user ID
2019            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2020            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2021            * @throws SystemException if a system exception occurred
2022            */
2023            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First(
2024                    long groupId, long userId,
2025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2026                    throws com.liferay.portal.kernel.exception.SystemException {
2027                    return getPersistence()
2028                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2029            }
2030    
2031            /**
2032            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2033            *
2034            * @param groupId the group ID
2035            * @param userId the user ID
2036            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2037            * @return the last matching journal article
2038            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2039            * @throws SystemException if a system exception occurred
2040            */
2041            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last(
2042                    long groupId, long userId,
2043                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2044                    throws com.liferay.portal.kernel.exception.SystemException,
2045                            com.liferay.portlet.journal.NoSuchArticleException {
2046                    return getPersistence()
2047                                       .findByG_U_Last(groupId, userId, orderByComparator);
2048            }
2049    
2050            /**
2051            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2052            *
2053            * @param groupId the group ID
2054            * @param userId the user ID
2055            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2056            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2057            * @throws SystemException if a system exception occurred
2058            */
2059            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last(
2060                    long groupId, long userId,
2061                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2062                    throws com.liferay.portal.kernel.exception.SystemException {
2063                    return getPersistence()
2064                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2065            }
2066    
2067            /**
2068            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2069            *
2070            * @param id the primary key of the current journal article
2071            * @param groupId the group ID
2072            * @param userId the user ID
2073            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2074            * @return the previous, current, and next journal article
2075            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2076            * @throws SystemException if a system exception occurred
2077            */
2078            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext(
2079                    long id, long groupId, long userId,
2080                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2081                    throws com.liferay.portal.kernel.exception.SystemException,
2082                            com.liferay.portlet.journal.NoSuchArticleException {
2083                    return getPersistence()
2084                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2085            }
2086    
2087            /**
2088            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2089            *
2090            * @param groupId the group ID
2091            * @param userId the user ID
2092            * @return the matching journal articles that the user has permission to view
2093            * @throws SystemException if a system exception occurred
2094            */
2095            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2096                    long groupId, long userId)
2097                    throws com.liferay.portal.kernel.exception.SystemException {
2098                    return getPersistence().filterFindByG_U(groupId, userId);
2099            }
2100    
2101            /**
2102            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2103            *
2104            * <p>
2105            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2106            * </p>
2107            *
2108            * @param groupId the group ID
2109            * @param userId the user ID
2110            * @param start the lower bound of the range of journal articles
2111            * @param end the upper bound of the range of journal articles (not inclusive)
2112            * @return the range of matching journal articles that the user has permission to view
2113            * @throws SystemException if a system exception occurred
2114            */
2115            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2116                    long groupId, long userId, int start, int end)
2117                    throws com.liferay.portal.kernel.exception.SystemException {
2118                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2119            }
2120    
2121            /**
2122            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2123            *
2124            * <p>
2125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2126            * </p>
2127            *
2128            * @param groupId the group ID
2129            * @param userId the user ID
2130            * @param start the lower bound of the range of journal articles
2131            * @param end the upper bound of the range of journal articles (not inclusive)
2132            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2133            * @return the ordered range of matching journal articles that the user has permission to view
2134            * @throws SystemException if a system exception occurred
2135            */
2136            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2137                    long groupId, long userId, int start, int end,
2138                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2139                    throws com.liferay.portal.kernel.exception.SystemException {
2140                    return getPersistence()
2141                                       .filterFindByG_U(groupId, userId, start, end,
2142                            orderByComparator);
2143            }
2144    
2145            /**
2146            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2147            *
2148            * @param id the primary key of the current journal article
2149            * @param groupId the group ID
2150            * @param userId the user ID
2151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2152            * @return the previous, current, and next journal article
2153            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2154            * @throws SystemException if a system exception occurred
2155            */
2156            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext(
2157                    long id, long groupId, long userId,
2158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2159                    throws com.liferay.portal.kernel.exception.SystemException,
2160                            com.liferay.portlet.journal.NoSuchArticleException {
2161                    return getPersistence()
2162                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2163                            orderByComparator);
2164            }
2165    
2166            /**
2167            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2168            *
2169            * @param groupId the group ID
2170            * @param userId the user ID
2171            * @throws SystemException if a system exception occurred
2172            */
2173            public static void removeByG_U(long groupId, long userId)
2174                    throws com.liferay.portal.kernel.exception.SystemException {
2175                    getPersistence().removeByG_U(groupId, userId);
2176            }
2177    
2178            /**
2179            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2180            *
2181            * @param groupId the group ID
2182            * @param userId the user ID
2183            * @return the number of matching journal articles
2184            * @throws SystemException if a system exception occurred
2185            */
2186            public static int countByG_U(long groupId, long userId)
2187                    throws com.liferay.portal.kernel.exception.SystemException {
2188                    return getPersistence().countByG_U(groupId, userId);
2189            }
2190    
2191            /**
2192            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2193            *
2194            * @param groupId the group ID
2195            * @param userId the user ID
2196            * @return the number of matching journal articles that the user has permission to view
2197            * @throws SystemException if a system exception occurred
2198            */
2199            public static int filterCountByG_U(long groupId, long userId)
2200                    throws com.liferay.portal.kernel.exception.SystemException {
2201                    return getPersistence().filterCountByG_U(groupId, userId);
2202            }
2203    
2204            /**
2205            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2206            *
2207            * @param groupId the group ID
2208            * @param folderId the folder ID
2209            * @return the matching journal articles
2210            * @throws SystemException if a system exception occurred
2211            */
2212            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2213                    long groupId, long folderId)
2214                    throws com.liferay.portal.kernel.exception.SystemException {
2215                    return getPersistence().findByG_F(groupId, folderId);
2216            }
2217    
2218            /**
2219            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2220            *
2221            * <p>
2222            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2223            * </p>
2224            *
2225            * @param groupId the group ID
2226            * @param folderId the folder ID
2227            * @param start the lower bound of the range of journal articles
2228            * @param end the upper bound of the range of journal articles (not inclusive)
2229            * @return the range of matching journal articles
2230            * @throws SystemException if a system exception occurred
2231            */
2232            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2233                    long groupId, long folderId, int start, int end)
2234                    throws com.liferay.portal.kernel.exception.SystemException {
2235                    return getPersistence().findByG_F(groupId, folderId, start, end);
2236            }
2237    
2238            /**
2239            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2240            *
2241            * <p>
2242            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2243            * </p>
2244            *
2245            * @param groupId the group ID
2246            * @param folderId the folder ID
2247            * @param start the lower bound of the range of journal articles
2248            * @param end the upper bound of the range of journal articles (not inclusive)
2249            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2250            * @return the ordered range of matching journal articles
2251            * @throws SystemException if a system exception occurred
2252            */
2253            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2254                    long groupId, long folderId, int start, int end,
2255                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2256                    throws com.liferay.portal.kernel.exception.SystemException {
2257                    return getPersistence()
2258                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2259            }
2260    
2261            /**
2262            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2263            *
2264            * @param groupId the group ID
2265            * @param folderId the folder ID
2266            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2267            * @return the first matching journal article
2268            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2269            * @throws SystemException if a system exception occurred
2270            */
2271            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First(
2272                    long groupId, long folderId,
2273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2274                    throws com.liferay.portal.kernel.exception.SystemException,
2275                            com.liferay.portlet.journal.NoSuchArticleException {
2276                    return getPersistence()
2277                                       .findByG_F_First(groupId, folderId, orderByComparator);
2278            }
2279    
2280            /**
2281            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2282            *
2283            * @param groupId the group ID
2284            * @param folderId the folder ID
2285            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2286            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2287            * @throws SystemException if a system exception occurred
2288            */
2289            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First(
2290                    long groupId, long folderId,
2291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2292                    throws com.liferay.portal.kernel.exception.SystemException {
2293                    return getPersistence()
2294                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2295            }
2296    
2297            /**
2298            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2299            *
2300            * @param groupId the group ID
2301            * @param folderId the folder ID
2302            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2303            * @return the last matching journal article
2304            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2305            * @throws SystemException if a system exception occurred
2306            */
2307            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last(
2308                    long groupId, long folderId,
2309                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2310                    throws com.liferay.portal.kernel.exception.SystemException,
2311                            com.liferay.portlet.journal.NoSuchArticleException {
2312                    return getPersistence()
2313                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2314            }
2315    
2316            /**
2317            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2318            *
2319            * @param groupId the group ID
2320            * @param folderId the folder ID
2321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2322            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2323            * @throws SystemException if a system exception occurred
2324            */
2325            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last(
2326                    long groupId, long folderId,
2327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2328                    throws com.liferay.portal.kernel.exception.SystemException {
2329                    return getPersistence()
2330                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2331            }
2332    
2333            /**
2334            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2335            *
2336            * @param id the primary key of the current journal article
2337            * @param groupId the group ID
2338            * @param folderId the folder ID
2339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2340            * @return the previous, current, and next journal article
2341            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2342            * @throws SystemException if a system exception occurred
2343            */
2344            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext(
2345                    long id, long groupId, long folderId,
2346                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2347                    throws com.liferay.portal.kernel.exception.SystemException,
2348                            com.liferay.portlet.journal.NoSuchArticleException {
2349                    return getPersistence()
2350                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2351                            orderByComparator);
2352            }
2353    
2354            /**
2355            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2356            *
2357            * @param groupId the group ID
2358            * @param folderId the folder ID
2359            * @return the matching journal articles that the user has permission to view
2360            * @throws SystemException if a system exception occurred
2361            */
2362            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2363                    long groupId, long folderId)
2364                    throws com.liferay.portal.kernel.exception.SystemException {
2365                    return getPersistence().filterFindByG_F(groupId, folderId);
2366            }
2367    
2368            /**
2369            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2370            *
2371            * <p>
2372            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2373            * </p>
2374            *
2375            * @param groupId the group ID
2376            * @param folderId the folder ID
2377            * @param start the lower bound of the range of journal articles
2378            * @param end the upper bound of the range of journal articles (not inclusive)
2379            * @return the range of matching journal articles that the user has permission to view
2380            * @throws SystemException if a system exception occurred
2381            */
2382            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2383                    long groupId, long folderId, int start, int end)
2384                    throws com.liferay.portal.kernel.exception.SystemException {
2385                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2386            }
2387    
2388            /**
2389            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2390            *
2391            * <p>
2392            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2393            * </p>
2394            *
2395            * @param groupId the group ID
2396            * @param folderId the folder ID
2397            * @param start the lower bound of the range of journal articles
2398            * @param end the upper bound of the range of journal articles (not inclusive)
2399            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2400            * @return the ordered range of matching journal articles that the user has permission to view
2401            * @throws SystemException if a system exception occurred
2402            */
2403            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2404                    long groupId, long folderId, int start, int end,
2405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2406                    throws com.liferay.portal.kernel.exception.SystemException {
2407                    return getPersistence()
2408                                       .filterFindByG_F(groupId, folderId, start, end,
2409                            orderByComparator);
2410            }
2411    
2412            /**
2413            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2414            *
2415            * @param id the primary key of the current journal article
2416            * @param groupId the group ID
2417            * @param folderId the folder ID
2418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2419            * @return the previous, current, and next journal article
2420            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2421            * @throws SystemException if a system exception occurred
2422            */
2423            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext(
2424                    long id, long groupId, long folderId,
2425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2426                    throws com.liferay.portal.kernel.exception.SystemException,
2427                            com.liferay.portlet.journal.NoSuchArticleException {
2428                    return getPersistence()
2429                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2430                            orderByComparator);
2431            }
2432    
2433            /**
2434            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2435            *
2436            * @param groupId the group ID
2437            * @param folderIds the folder IDs
2438            * @return the matching journal articles that the user has permission to view
2439            * @throws SystemException if a system exception occurred
2440            */
2441            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2442                    long groupId, long[] folderIds)
2443                    throws com.liferay.portal.kernel.exception.SystemException {
2444                    return getPersistence().filterFindByG_F(groupId, folderIds);
2445            }
2446    
2447            /**
2448            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2449            *
2450            * <p>
2451            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2452            * </p>
2453            *
2454            * @param groupId the group ID
2455            * @param folderIds the folder IDs
2456            * @param start the lower bound of the range of journal articles
2457            * @param end the upper bound of the range of journal articles (not inclusive)
2458            * @return the range of matching journal articles that the user has permission to view
2459            * @throws SystemException if a system exception occurred
2460            */
2461            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2462                    long groupId, long[] folderIds, int start, int end)
2463                    throws com.liferay.portal.kernel.exception.SystemException {
2464                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2465            }
2466    
2467            /**
2468            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2469            *
2470            * <p>
2471            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2472            * </p>
2473            *
2474            * @param groupId the group ID
2475            * @param folderIds the folder IDs
2476            * @param start the lower bound of the range of journal articles
2477            * @param end the upper bound of the range of journal articles (not inclusive)
2478            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2479            * @return the ordered range of matching journal articles that the user has permission to view
2480            * @throws SystemException if a system exception occurred
2481            */
2482            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2483                    long groupId, long[] folderIds, int start, int end,
2484                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2485                    throws com.liferay.portal.kernel.exception.SystemException {
2486                    return getPersistence()
2487                                       .filterFindByG_F(groupId, folderIds, start, end,
2488                            orderByComparator);
2489            }
2490    
2491            /**
2492            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2493            *
2494            * <p>
2495            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2496            * </p>
2497            *
2498            * @param groupId the group ID
2499            * @param folderIds the folder IDs
2500            * @return the matching journal articles
2501            * @throws SystemException if a system exception occurred
2502            */
2503            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2504                    long groupId, long[] folderIds)
2505                    throws com.liferay.portal.kernel.exception.SystemException {
2506                    return getPersistence().findByG_F(groupId, folderIds);
2507            }
2508    
2509            /**
2510            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2511            *
2512            * <p>
2513            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2514            * </p>
2515            *
2516            * @param groupId the group ID
2517            * @param folderIds the folder IDs
2518            * @param start the lower bound of the range of journal articles
2519            * @param end the upper bound of the range of journal articles (not inclusive)
2520            * @return the range of matching journal articles
2521            * @throws SystemException if a system exception occurred
2522            */
2523            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2524                    long groupId, long[] folderIds, int start, int end)
2525                    throws com.liferay.portal.kernel.exception.SystemException {
2526                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2527            }
2528    
2529            /**
2530            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2531            *
2532            * <p>
2533            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2534            * </p>
2535            *
2536            * @param groupId the group ID
2537            * @param folderIds the folder IDs
2538            * @param start the lower bound of the range of journal articles
2539            * @param end the upper bound of the range of journal articles (not inclusive)
2540            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2541            * @return the ordered range of matching journal articles
2542            * @throws SystemException if a system exception occurred
2543            */
2544            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2545                    long groupId, long[] folderIds, int start, int end,
2546                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2547                    throws com.liferay.portal.kernel.exception.SystemException {
2548                    return getPersistence()
2549                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2550            }
2551    
2552            /**
2553            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2554            *
2555            * @param groupId the group ID
2556            * @param folderId the folder ID
2557            * @throws SystemException if a system exception occurred
2558            */
2559            public static void removeByG_F(long groupId, long folderId)
2560                    throws com.liferay.portal.kernel.exception.SystemException {
2561                    getPersistence().removeByG_F(groupId, folderId);
2562            }
2563    
2564            /**
2565            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2566            *
2567            * @param groupId the group ID
2568            * @param folderId the folder ID
2569            * @return the number of matching journal articles
2570            * @throws SystemException if a system exception occurred
2571            */
2572            public static int countByG_F(long groupId, long folderId)
2573                    throws com.liferay.portal.kernel.exception.SystemException {
2574                    return getPersistence().countByG_F(groupId, folderId);
2575            }
2576    
2577            /**
2578            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2579            *
2580            * @param groupId the group ID
2581            * @param folderIds the folder IDs
2582            * @return the number of matching journal articles
2583            * @throws SystemException if a system exception occurred
2584            */
2585            public static int countByG_F(long groupId, long[] folderIds)
2586                    throws com.liferay.portal.kernel.exception.SystemException {
2587                    return getPersistence().countByG_F(groupId, folderIds);
2588            }
2589    
2590            /**
2591            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2592            *
2593            * @param groupId the group ID
2594            * @param folderId the folder ID
2595            * @return the number of matching journal articles that the user has permission to view
2596            * @throws SystemException if a system exception occurred
2597            */
2598            public static int filterCountByG_F(long groupId, long folderId)
2599                    throws com.liferay.portal.kernel.exception.SystemException {
2600                    return getPersistence().filterCountByG_F(groupId, folderId);
2601            }
2602    
2603            /**
2604            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2605            *
2606            * @param groupId the group ID
2607            * @param folderIds the folder IDs
2608            * @return the number of matching journal articles that the user has permission to view
2609            * @throws SystemException if a system exception occurred
2610            */
2611            public static int filterCountByG_F(long groupId, long[] folderIds)
2612                    throws com.liferay.portal.kernel.exception.SystemException {
2613                    return getPersistence().filterCountByG_F(groupId, folderIds);
2614            }
2615    
2616            /**
2617            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2618            *
2619            * @param groupId the group ID
2620            * @param articleId the article ID
2621            * @return the matching journal articles
2622            * @throws SystemException if a system exception occurred
2623            */
2624            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2625                    long groupId, java.lang.String articleId)
2626                    throws com.liferay.portal.kernel.exception.SystemException {
2627                    return getPersistence().findByG_A(groupId, articleId);
2628            }
2629    
2630            /**
2631            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2632            *
2633            * <p>
2634            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2635            * </p>
2636            *
2637            * @param groupId the group ID
2638            * @param articleId the article ID
2639            * @param start the lower bound of the range of journal articles
2640            * @param end the upper bound of the range of journal articles (not inclusive)
2641            * @return the range of matching journal articles
2642            * @throws SystemException if a system exception occurred
2643            */
2644            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2645                    long groupId, java.lang.String articleId, int start, int end)
2646                    throws com.liferay.portal.kernel.exception.SystemException {
2647                    return getPersistence().findByG_A(groupId, articleId, start, end);
2648            }
2649    
2650            /**
2651            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2652            *
2653            * <p>
2654            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2655            * </p>
2656            *
2657            * @param groupId the group ID
2658            * @param articleId the article ID
2659            * @param start the lower bound of the range of journal articles
2660            * @param end the upper bound of the range of journal articles (not inclusive)
2661            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2662            * @return the ordered range of matching journal articles
2663            * @throws SystemException if a system exception occurred
2664            */
2665            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2666                    long groupId, java.lang.String articleId, int start, int end,
2667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2668                    throws com.liferay.portal.kernel.exception.SystemException {
2669                    return getPersistence()
2670                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2671            }
2672    
2673            /**
2674            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2675            *
2676            * @param groupId the group ID
2677            * @param articleId the article ID
2678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2679            * @return the first matching journal article
2680            * @throws com.liferay.portlet.journal.NoSuchArticleException 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 findByG_A_First(
2684                    long groupId, java.lang.String articleId,
2685                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2686                    throws com.liferay.portal.kernel.exception.SystemException,
2687                            com.liferay.portlet.journal.NoSuchArticleException {
2688                    return getPersistence()
2689                                       .findByG_A_First(groupId, articleId, orderByComparator);
2690            }
2691    
2692            /**
2693            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2694            *
2695            * @param groupId the group ID
2696            * @param articleId the article ID
2697            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2698            * @return the first matching journal article, or <code>null</code> 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 fetchByG_A_First(
2702                    long groupId, java.lang.String articleId,
2703                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2704                    throws com.liferay.portal.kernel.exception.SystemException {
2705                    return getPersistence()
2706                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
2707            }
2708    
2709            /**
2710            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2711            *
2712            * @param groupId the group ID
2713            * @param articleId the article ID
2714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2715            * @return the last matching journal article
2716            * @throws com.liferay.portlet.journal.NoSuchArticleException 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 findByG_A_Last(
2720                    long groupId, java.lang.String articleId,
2721                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2722                    throws com.liferay.portal.kernel.exception.SystemException,
2723                            com.liferay.portlet.journal.NoSuchArticleException {
2724                    return getPersistence()
2725                                       .findByG_A_Last(groupId, articleId, orderByComparator);
2726            }
2727    
2728            /**
2729            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2730            *
2731            * @param groupId the group ID
2732            * @param articleId the article ID
2733            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2734            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2735            * @throws SystemException if a system exception occurred
2736            */
2737            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
2738                    long groupId, java.lang.String articleId,
2739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2740                    throws com.liferay.portal.kernel.exception.SystemException {
2741                    return getPersistence()
2742                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
2743            }
2744    
2745            /**
2746            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2747            *
2748            * @param id the primary key of the current journal article
2749            * @param groupId the group ID
2750            * @param articleId the article ID
2751            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2752            * @return the previous, current, and next journal article
2753            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2754            * @throws SystemException if a system exception occurred
2755            */
2756            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
2757                    long id, long groupId, java.lang.String articleId,
2758                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2759                    throws com.liferay.portal.kernel.exception.SystemException,
2760                            com.liferay.portlet.journal.NoSuchArticleException {
2761                    return getPersistence()
2762                                       .findByG_A_PrevAndNext(id, groupId, articleId,
2763                            orderByComparator);
2764            }
2765    
2766            /**
2767            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2768            *
2769            * @param groupId the group ID
2770            * @param articleId the article ID
2771            * @return the matching journal articles that the user has permission to view
2772            * @throws SystemException if a system exception occurred
2773            */
2774            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2775                    long groupId, java.lang.String articleId)
2776                    throws com.liferay.portal.kernel.exception.SystemException {
2777                    return getPersistence().filterFindByG_A(groupId, articleId);
2778            }
2779    
2780            /**
2781            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2782            *
2783            * <p>
2784            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2785            * </p>
2786            *
2787            * @param groupId the group ID
2788            * @param articleId the article ID
2789            * @param start the lower bound of the range of journal articles
2790            * @param end the upper bound of the range of journal articles (not inclusive)
2791            * @return the range of matching journal articles that the user has permission to view
2792            * @throws SystemException if a system exception occurred
2793            */
2794            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2795                    long groupId, java.lang.String articleId, int start, int end)
2796                    throws com.liferay.portal.kernel.exception.SystemException {
2797                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
2798            }
2799    
2800            /**
2801            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
2802            *
2803            * <p>
2804            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2805            * </p>
2806            *
2807            * @param groupId the group ID
2808            * @param articleId the article ID
2809            * @param start the lower bound of the range of journal articles
2810            * @param end the upper bound of the range of journal articles (not inclusive)
2811            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2812            * @return the ordered range of matching journal articles that the user has permission to view
2813            * @throws SystemException if a system exception occurred
2814            */
2815            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2816                    long groupId, java.lang.String articleId, int start, int end,
2817                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2818                    throws com.liferay.portal.kernel.exception.SystemException {
2819                    return getPersistence()
2820                                       .filterFindByG_A(groupId, articleId, start, end,
2821                            orderByComparator);
2822            }
2823    
2824            /**
2825            * 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;.
2826            *
2827            * @param id the primary key of the current journal article
2828            * @param groupId the group ID
2829            * @param articleId the article ID
2830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2831            * @return the previous, current, and next journal article
2832            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2833            * @throws SystemException if a system exception occurred
2834            */
2835            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
2836                    long id, long groupId, java.lang.String articleId,
2837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2838                    throws com.liferay.portal.kernel.exception.SystemException,
2839                            com.liferay.portlet.journal.NoSuchArticleException {
2840                    return getPersistence()
2841                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
2842                            orderByComparator);
2843            }
2844    
2845            /**
2846            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2847            *
2848            * @param groupId the group ID
2849            * @param articleId the article ID
2850            * @throws SystemException if a system exception occurred
2851            */
2852            public static void removeByG_A(long groupId, java.lang.String articleId)
2853                    throws com.liferay.portal.kernel.exception.SystemException {
2854                    getPersistence().removeByG_A(groupId, articleId);
2855            }
2856    
2857            /**
2858            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
2859            *
2860            * @param groupId the group ID
2861            * @param articleId the article ID
2862            * @return the number of matching journal articles
2863            * @throws SystemException if a system exception occurred
2864            */
2865            public static int countByG_A(long groupId, java.lang.String articleId)
2866                    throws com.liferay.portal.kernel.exception.SystemException {
2867                    return getPersistence().countByG_A(groupId, articleId);
2868            }
2869    
2870            /**
2871            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2872            *
2873            * @param groupId the group ID
2874            * @param articleId the article ID
2875            * @return the number of matching journal articles that the user has permission to view
2876            * @throws SystemException if a system exception occurred
2877            */
2878            public static int filterCountByG_A(long groupId, java.lang.String articleId)
2879                    throws com.liferay.portal.kernel.exception.SystemException {
2880                    return getPersistence().filterCountByG_A(groupId, articleId);
2881            }
2882    
2883            /**
2884            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
2885            *
2886            * @param groupId the group ID
2887            * @param urlTitle the url title
2888            * @return the matching journal articles
2889            * @throws SystemException if a system exception occurred
2890            */
2891            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2892                    long groupId, java.lang.String urlTitle)
2893                    throws com.liferay.portal.kernel.exception.SystemException {
2894                    return getPersistence().findByG_UT(groupId, urlTitle);
2895            }
2896    
2897            /**
2898            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2899            *
2900            * <p>
2901            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2902            * </p>
2903            *
2904            * @param groupId the group ID
2905            * @param urlTitle the url title
2906            * @param start the lower bound of the range of journal articles
2907            * @param end the upper bound of the range of journal articles (not inclusive)
2908            * @return the range of matching journal articles
2909            * @throws SystemException if a system exception occurred
2910            */
2911            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2912                    long groupId, java.lang.String urlTitle, int start, int end)
2913                    throws com.liferay.portal.kernel.exception.SystemException {
2914                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
2915            }
2916    
2917            /**
2918            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2919            *
2920            * <p>
2921            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2922            * </p>
2923            *
2924            * @param groupId the group ID
2925            * @param urlTitle the url title
2926            * @param start the lower bound of the range of journal articles
2927            * @param end the upper bound of the range of journal articles (not inclusive)
2928            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2929            * @return the ordered range of matching journal articles
2930            * @throws SystemException if a system exception occurred
2931            */
2932            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2933                    long groupId, java.lang.String urlTitle, int start, int end,
2934                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2935                    throws com.liferay.portal.kernel.exception.SystemException {
2936                    return getPersistence()
2937                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
2938            }
2939    
2940            /**
2941            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2942            *
2943            * @param groupId the group ID
2944            * @param urlTitle the url title
2945            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2946            * @return the first matching journal article
2947            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2948            * @throws SystemException if a system exception occurred
2949            */
2950            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
2951                    long groupId, java.lang.String urlTitle,
2952                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2953                    throws com.liferay.portal.kernel.exception.SystemException,
2954                            com.liferay.portlet.journal.NoSuchArticleException {
2955                    return getPersistence()
2956                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
2957            }
2958    
2959            /**
2960            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2961            *
2962            * @param groupId the group ID
2963            * @param urlTitle the url title
2964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2965            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2966            * @throws SystemException if a system exception occurred
2967            */
2968            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
2969                    long groupId, java.lang.String urlTitle,
2970                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2971                    throws com.liferay.portal.kernel.exception.SystemException {
2972                    return getPersistence()
2973                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
2974            }
2975    
2976            /**
2977            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2978            *
2979            * @param groupId the group ID
2980            * @param urlTitle the url title
2981            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2982            * @return the last matching journal article
2983            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2984            * @throws SystemException if a system exception occurred
2985            */
2986            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
2987                    long groupId, java.lang.String urlTitle,
2988                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2989                    throws com.liferay.portal.kernel.exception.SystemException,
2990                            com.liferay.portlet.journal.NoSuchArticleException {
2991                    return getPersistence()
2992                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
2993            }
2994    
2995            /**
2996            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2997            *
2998            * @param groupId the group ID
2999            * @param urlTitle the url title
3000            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3001            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3002            * @throws SystemException if a system exception occurred
3003            */
3004            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
3005                    long groupId, java.lang.String urlTitle,
3006                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3007                    throws com.liferay.portal.kernel.exception.SystemException {
3008                    return getPersistence()
3009                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
3010            }
3011    
3012            /**
3013            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3014            *
3015            * @param id the primary key of the current journal article
3016            * @param groupId the group ID
3017            * @param urlTitle the url title
3018            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3019            * @return the previous, current, and next journal article
3020            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3021            * @throws SystemException if a system exception occurred
3022            */
3023            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
3024                    long id, long groupId, java.lang.String urlTitle,
3025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3026                    throws com.liferay.portal.kernel.exception.SystemException,
3027                            com.liferay.portlet.journal.NoSuchArticleException {
3028                    return getPersistence()
3029                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
3030                            orderByComparator);
3031            }
3032    
3033            /**
3034            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3035            *
3036            * @param groupId the group ID
3037            * @param urlTitle the url title
3038            * @return the matching journal articles that the user has permission to view
3039            * @throws SystemException if a system exception occurred
3040            */
3041            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3042                    long groupId, java.lang.String urlTitle)
3043                    throws com.liferay.portal.kernel.exception.SystemException {
3044                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
3045            }
3046    
3047            /**
3048            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3049            *
3050            * <p>
3051            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3052            * </p>
3053            *
3054            * @param groupId the group ID
3055            * @param urlTitle the url title
3056            * @param start the lower bound of the range of journal articles
3057            * @param end the upper bound of the range of journal articles (not inclusive)
3058            * @return the range of matching journal articles that the user has permission to view
3059            * @throws SystemException if a system exception occurred
3060            */
3061            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3062                    long groupId, java.lang.String urlTitle, int start, int end)
3063                    throws com.liferay.portal.kernel.exception.SystemException {
3064                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
3065            }
3066    
3067            /**
3068            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
3069            *
3070            * <p>
3071            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3072            * </p>
3073            *
3074            * @param groupId the group ID
3075            * @param urlTitle the url title
3076            * @param start the lower bound of the range of journal articles
3077            * @param end the upper bound of the range of journal articles (not inclusive)
3078            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3079            * @return the ordered range of matching journal articles that the user has permission to view
3080            * @throws SystemException if a system exception occurred
3081            */
3082            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3083                    long groupId, java.lang.String urlTitle, int start, int end,
3084                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3085                    throws com.liferay.portal.kernel.exception.SystemException {
3086                    return getPersistence()
3087                                       .filterFindByG_UT(groupId, urlTitle, start, end,
3088                            orderByComparator);
3089            }
3090    
3091            /**
3092            * 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;.
3093            *
3094            * @param id the primary key of the current journal article
3095            * @param groupId the group ID
3096            * @param urlTitle the url title
3097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3098            * @return the previous, current, and next journal article
3099            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3100            * @throws SystemException if a system exception occurred
3101            */
3102            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
3103                    long id, long groupId, java.lang.String urlTitle,
3104                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3105                    throws com.liferay.portal.kernel.exception.SystemException,
3106                            com.liferay.portlet.journal.NoSuchArticleException {
3107                    return getPersistence()
3108                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
3109                            orderByComparator);
3110            }
3111    
3112            /**
3113            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3114            *
3115            * @param groupId the group ID
3116            * @param urlTitle the url title
3117            * @throws SystemException if a system exception occurred
3118            */
3119            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
3120                    throws com.liferay.portal.kernel.exception.SystemException {
3121                    getPersistence().removeByG_UT(groupId, urlTitle);
3122            }
3123    
3124            /**
3125            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3126            *
3127            * @param groupId the group ID
3128            * @param urlTitle the url title
3129            * @return the number of matching journal articles
3130            * @throws SystemException if a system exception occurred
3131            */
3132            public static int countByG_UT(long groupId, java.lang.String urlTitle)
3133                    throws com.liferay.portal.kernel.exception.SystemException {
3134                    return getPersistence().countByG_UT(groupId, urlTitle);
3135            }
3136    
3137            /**
3138            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3139            *
3140            * @param groupId the group ID
3141            * @param urlTitle the url title
3142            * @return the number of matching journal articles that the user has permission to view
3143            * @throws SystemException if a system exception occurred
3144            */
3145            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
3146                    throws com.liferay.portal.kernel.exception.SystemException {
3147                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3148            }
3149    
3150            /**
3151            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
3152            *
3153            * @param groupId the group ID
3154            * @param structureId the structure ID
3155            * @return the matching journal articles
3156            * @throws SystemException if a system exception occurred
3157            */
3158            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3159                    long groupId, java.lang.String structureId)
3160                    throws com.liferay.portal.kernel.exception.SystemException {
3161                    return getPersistence().findByG_S(groupId, structureId);
3162            }
3163    
3164            /**
3165            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3169            * </p>
3170            *
3171            * @param groupId the group ID
3172            * @param structureId the structure ID
3173            * @param start the lower bound of the range of journal articles
3174            * @param end the upper bound of the range of journal articles (not inclusive)
3175            * @return the range of matching journal articles
3176            * @throws SystemException if a system exception occurred
3177            */
3178            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3179                    long groupId, java.lang.String structureId, int start, int end)
3180                    throws com.liferay.portal.kernel.exception.SystemException {
3181                    return getPersistence().findByG_S(groupId, structureId, start, end);
3182            }
3183    
3184            /**
3185            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
3186            *
3187            * <p>
3188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3189            * </p>
3190            *
3191            * @param groupId the group ID
3192            * @param structureId the structure ID
3193            * @param start the lower bound of the range of journal articles
3194            * @param end the upper bound of the range of journal articles (not inclusive)
3195            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3196            * @return the ordered range of matching journal articles
3197            * @throws SystemException if a system exception occurred
3198            */
3199            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3200                    long groupId, java.lang.String structureId, int start, int end,
3201                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3202                    throws com.liferay.portal.kernel.exception.SystemException {
3203                    return getPersistence()
3204                                       .findByG_S(groupId, structureId, start, end,
3205                            orderByComparator);
3206            }
3207    
3208            /**
3209            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3210            *
3211            * @param groupId the group ID
3212            * @param structureId the structure ID
3213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3214            * @return the first matching journal article
3215            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3216            * @throws SystemException if a system exception occurred
3217            */
3218            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
3219                    long groupId, java.lang.String structureId,
3220                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3221                    throws com.liferay.portal.kernel.exception.SystemException,
3222                            com.liferay.portlet.journal.NoSuchArticleException {
3223                    return getPersistence()
3224                                       .findByG_S_First(groupId, structureId, orderByComparator);
3225            }
3226    
3227            /**
3228            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3229            *
3230            * @param groupId the group ID
3231            * @param structureId the structure ID
3232            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3233            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3234            * @throws SystemException if a system exception occurred
3235            */
3236            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
3237                    long groupId, java.lang.String structureId,
3238                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3239                    throws com.liferay.portal.kernel.exception.SystemException {
3240                    return getPersistence()
3241                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
3242            }
3243    
3244            /**
3245            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3246            *
3247            * @param groupId the group ID
3248            * @param structureId the structure ID
3249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3250            * @return the last matching journal article
3251            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3252            * @throws SystemException if a system exception occurred
3253            */
3254            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
3255                    long groupId, java.lang.String structureId,
3256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3257                    throws com.liferay.portal.kernel.exception.SystemException,
3258                            com.liferay.portlet.journal.NoSuchArticleException {
3259                    return getPersistence()
3260                                       .findByG_S_Last(groupId, structureId, orderByComparator);
3261            }
3262    
3263            /**
3264            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3265            *
3266            * @param groupId the group ID
3267            * @param structureId the structure ID
3268            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3269            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3270            * @throws SystemException if a system exception occurred
3271            */
3272            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
3273                    long groupId, java.lang.String structureId,
3274                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3275                    throws com.liferay.portal.kernel.exception.SystemException {
3276                    return getPersistence()
3277                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
3278            }
3279    
3280            /**
3281            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3282            *
3283            * @param id the primary key of the current journal article
3284            * @param groupId the group ID
3285            * @param structureId the structure ID
3286            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3287            * @return the previous, current, and next journal article
3288            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3289            * @throws SystemException if a system exception occurred
3290            */
3291            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
3292                    long id, long groupId, java.lang.String structureId,
3293                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3294                    throws com.liferay.portal.kernel.exception.SystemException,
3295                            com.liferay.portlet.journal.NoSuchArticleException {
3296                    return getPersistence()
3297                                       .findByG_S_PrevAndNext(id, groupId, structureId,
3298                            orderByComparator);
3299            }
3300    
3301            /**
3302            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3303            *
3304            * @param groupId the group ID
3305            * @param structureId the structure ID
3306            * @return the matching journal articles that the user has permission to view
3307            * @throws SystemException if a system exception occurred
3308            */
3309            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3310                    long groupId, java.lang.String structureId)
3311                    throws com.liferay.portal.kernel.exception.SystemException {
3312                    return getPersistence().filterFindByG_S(groupId, structureId);
3313            }
3314    
3315            /**
3316            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3317            *
3318            * <p>
3319            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3320            * </p>
3321            *
3322            * @param groupId the group ID
3323            * @param structureId the structure ID
3324            * @param start the lower bound of the range of journal articles
3325            * @param end the upper bound of the range of journal articles (not inclusive)
3326            * @return the range of matching journal articles that the user has permission to view
3327            * @throws SystemException if a system exception occurred
3328            */
3329            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3330                    long groupId, java.lang.String structureId, int start, int end)
3331                    throws com.liferay.portal.kernel.exception.SystemException {
3332                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
3333            }
3334    
3335            /**
3336            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
3337            *
3338            * <p>
3339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3340            * </p>
3341            *
3342            * @param groupId the group ID
3343            * @param structureId the structure ID
3344            * @param start the lower bound of the range of journal articles
3345            * @param end the upper bound of the range of journal articles (not inclusive)
3346            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3347            * @return the ordered range of matching journal articles that the user has permission to view
3348            * @throws SystemException if a system exception occurred
3349            */
3350            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3351                    long groupId, java.lang.String structureId, int start, int end,
3352                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3353                    throws com.liferay.portal.kernel.exception.SystemException {
3354                    return getPersistence()
3355                                       .filterFindByG_S(groupId, structureId, start, end,
3356                            orderByComparator);
3357            }
3358    
3359            /**
3360            * 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;.
3361            *
3362            * @param id the primary key of the current journal article
3363            * @param groupId the group ID
3364            * @param structureId the structure ID
3365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3366            * @return the previous, current, and next journal article
3367            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3368            * @throws SystemException if a system exception occurred
3369            */
3370            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
3371                    long id, long groupId, java.lang.String structureId,
3372                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3373                    throws com.liferay.portal.kernel.exception.SystemException,
3374                            com.liferay.portlet.journal.NoSuchArticleException {
3375                    return getPersistence()
3376                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
3377                            orderByComparator);
3378            }
3379    
3380            /**
3381            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
3382            *
3383            * @param groupId the group ID
3384            * @param structureId the structure ID
3385            * @throws SystemException if a system exception occurred
3386            */
3387            public static void removeByG_S(long groupId, java.lang.String structureId)
3388                    throws com.liferay.portal.kernel.exception.SystemException {
3389                    getPersistence().removeByG_S(groupId, structureId);
3390            }
3391    
3392            /**
3393            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
3394            *
3395            * @param groupId the group ID
3396            * @param structureId the structure ID
3397            * @return the number of matching journal articles
3398            * @throws SystemException if a system exception occurred
3399            */
3400            public static int countByG_S(long groupId, java.lang.String structureId)
3401                    throws com.liferay.portal.kernel.exception.SystemException {
3402                    return getPersistence().countByG_S(groupId, structureId);
3403            }
3404    
3405            /**
3406            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3407            *
3408            * @param groupId the group ID
3409            * @param structureId the structure ID
3410            * @return the number of matching journal articles that the user has permission to view
3411            * @throws SystemException if a system exception occurred
3412            */
3413            public static int filterCountByG_S(long groupId,
3414                    java.lang.String structureId)
3415                    throws com.liferay.portal.kernel.exception.SystemException {
3416                    return getPersistence().filterCountByG_S(groupId, structureId);
3417            }
3418    
3419            /**
3420            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
3421            *
3422            * @param groupId the group ID
3423            * @param templateId the template ID
3424            * @return the matching journal articles
3425            * @throws SystemException if a system exception occurred
3426            */
3427            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3428                    long groupId, java.lang.String templateId)
3429                    throws com.liferay.portal.kernel.exception.SystemException {
3430                    return getPersistence().findByG_T(groupId, templateId);
3431            }
3432    
3433            /**
3434            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
3435            *
3436            * <p>
3437            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3438            * </p>
3439            *
3440            * @param groupId the group ID
3441            * @param templateId the template ID
3442            * @param start the lower bound of the range of journal articles
3443            * @param end the upper bound of the range of journal articles (not inclusive)
3444            * @return the range of matching journal articles
3445            * @throws SystemException if a system exception occurred
3446            */
3447            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3448                    long groupId, java.lang.String templateId, int start, int end)
3449                    throws com.liferay.portal.kernel.exception.SystemException {
3450                    return getPersistence().findByG_T(groupId, templateId, start, end);
3451            }
3452    
3453            /**
3454            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
3455            *
3456            * <p>
3457            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3458            * </p>
3459            *
3460            * @param groupId the group ID
3461            * @param templateId the template ID
3462            * @param start the lower bound of the range of journal articles
3463            * @param end the upper bound of the range of journal articles (not inclusive)
3464            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3465            * @return the ordered range of matching journal articles
3466            * @throws SystemException if a system exception occurred
3467            */
3468            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3469                    long groupId, java.lang.String templateId, int start, int end,
3470                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3471                    throws com.liferay.portal.kernel.exception.SystemException {
3472                    return getPersistence()
3473                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
3474            }
3475    
3476            /**
3477            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3478            *
3479            * @param groupId the group ID
3480            * @param templateId the template ID
3481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3482            * @return the first matching journal article
3483            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3484            * @throws SystemException if a system exception occurred
3485            */
3486            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
3487                    long groupId, java.lang.String templateId,
3488                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3489                    throws com.liferay.portal.kernel.exception.SystemException,
3490                            com.liferay.portlet.journal.NoSuchArticleException {
3491                    return getPersistence()
3492                                       .findByG_T_First(groupId, templateId, orderByComparator);
3493            }
3494    
3495            /**
3496            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3497            *
3498            * @param groupId the group ID
3499            * @param templateId the template ID
3500            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3501            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3502            * @throws SystemException if a system exception occurred
3503            */
3504            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
3505                    long groupId, java.lang.String templateId,
3506                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3507                    throws com.liferay.portal.kernel.exception.SystemException {
3508                    return getPersistence()
3509                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
3510            }
3511    
3512            /**
3513            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3514            *
3515            * @param groupId the group ID
3516            * @param templateId the template ID
3517            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3518            * @return the last matching journal article
3519            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3520            * @throws SystemException if a system exception occurred
3521            */
3522            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
3523                    long groupId, java.lang.String templateId,
3524                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3525                    throws com.liferay.portal.kernel.exception.SystemException,
3526                            com.liferay.portlet.journal.NoSuchArticleException {
3527                    return getPersistence()
3528                                       .findByG_T_Last(groupId, templateId, orderByComparator);
3529            }
3530    
3531            /**
3532            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3533            *
3534            * @param groupId the group ID
3535            * @param templateId the template ID
3536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3537            * @return the last matching journal article, or <code>null</code> 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 fetchByG_T_Last(
3541                    long groupId, java.lang.String templateId,
3542                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3543                    throws com.liferay.portal.kernel.exception.SystemException {
3544                    return getPersistence()
3545                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
3546            }
3547    
3548            /**
3549            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3550            *
3551            * @param id the primary key of the current journal article
3552            * @param groupId the group ID
3553            * @param templateId the template ID
3554            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3555            * @return the previous, current, and next journal article
3556            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3557            * @throws SystemException if a system exception occurred
3558            */
3559            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
3560                    long id, long groupId, java.lang.String templateId,
3561                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3562                    throws com.liferay.portal.kernel.exception.SystemException,
3563                            com.liferay.portlet.journal.NoSuchArticleException {
3564                    return getPersistence()
3565                                       .findByG_T_PrevAndNext(id, groupId, templateId,
3566                            orderByComparator);
3567            }
3568    
3569            /**
3570            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3571            *
3572            * @param groupId the group ID
3573            * @param templateId the template ID
3574            * @return the matching journal articles that the user has permission to view
3575            * @throws SystemException if a system exception occurred
3576            */
3577            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3578                    long groupId, java.lang.String templateId)
3579                    throws com.liferay.portal.kernel.exception.SystemException {
3580                    return getPersistence().filterFindByG_T(groupId, templateId);
3581            }
3582    
3583            /**
3584            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3585            *
3586            * <p>
3587            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3588            * </p>
3589            *
3590            * @param groupId the group ID
3591            * @param templateId the template ID
3592            * @param start the lower bound of the range of journal articles
3593            * @param end the upper bound of the range of journal articles (not inclusive)
3594            * @return the range of matching journal articles that the user has permission to view
3595            * @throws SystemException if a system exception occurred
3596            */
3597            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3598                    long groupId, java.lang.String templateId, int start, int end)
3599                    throws com.liferay.portal.kernel.exception.SystemException {
3600                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
3601            }
3602    
3603            /**
3604            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
3605            *
3606            * <p>
3607            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3608            * </p>
3609            *
3610            * @param groupId the group ID
3611            * @param templateId the template ID
3612            * @param start the lower bound of the range of journal articles
3613            * @param end the upper bound of the range of journal articles (not inclusive)
3614            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3615            * @return the ordered range of matching journal articles that the user has permission to view
3616            * @throws SystemException if a system exception occurred
3617            */
3618            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3619                    long groupId, java.lang.String templateId, int start, int end,
3620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3621                    throws com.liferay.portal.kernel.exception.SystemException {
3622                    return getPersistence()
3623                                       .filterFindByG_T(groupId, templateId, start, end,
3624                            orderByComparator);
3625            }
3626    
3627            /**
3628            * 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;.
3629            *
3630            * @param id the primary key of the current journal article
3631            * @param groupId the group ID
3632            * @param templateId the template ID
3633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3634            * @return the previous, current, and next journal article
3635            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3636            * @throws SystemException if a system exception occurred
3637            */
3638            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
3639                    long id, long groupId, java.lang.String templateId,
3640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3641                    throws com.liferay.portal.kernel.exception.SystemException,
3642                            com.liferay.portlet.journal.NoSuchArticleException {
3643                    return getPersistence()
3644                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
3645                            orderByComparator);
3646            }
3647    
3648            /**
3649            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
3650            *
3651            * @param groupId the group ID
3652            * @param templateId the template ID
3653            * @throws SystemException if a system exception occurred
3654            */
3655            public static void removeByG_T(long groupId, java.lang.String templateId)
3656                    throws com.liferay.portal.kernel.exception.SystemException {
3657                    getPersistence().removeByG_T(groupId, templateId);
3658            }
3659    
3660            /**
3661            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
3662            *
3663            * @param groupId the group ID
3664            * @param templateId the template ID
3665            * @return the number of matching journal articles
3666            * @throws SystemException if a system exception occurred
3667            */
3668            public static int countByG_T(long groupId, java.lang.String templateId)
3669                    throws com.liferay.portal.kernel.exception.SystemException {
3670                    return getPersistence().countByG_T(groupId, templateId);
3671            }
3672    
3673            /**
3674            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3675            *
3676            * @param groupId the group ID
3677            * @param templateId the template ID
3678            * @return the number of matching journal articles that the user has permission to view
3679            * @throws SystemException if a system exception occurred
3680            */
3681            public static int filterCountByG_T(long groupId, java.lang.String templateId)
3682                    throws com.liferay.portal.kernel.exception.SystemException {
3683                    return getPersistence().filterCountByG_T(groupId, templateId);
3684            }
3685    
3686            /**
3687            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3688            *
3689            * @param groupId the group ID
3690            * @param layoutUuid the layout uuid
3691            * @return the matching journal articles
3692            * @throws SystemException if a system exception occurred
3693            */
3694            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3695                    long groupId, java.lang.String layoutUuid)
3696                    throws com.liferay.portal.kernel.exception.SystemException {
3697                    return getPersistence().findByG_L(groupId, layoutUuid);
3698            }
3699    
3700            /**
3701            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3702            *
3703            * <p>
3704            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3705            * </p>
3706            *
3707            * @param groupId the group ID
3708            * @param layoutUuid the layout uuid
3709            * @param start the lower bound of the range of journal articles
3710            * @param end the upper bound of the range of journal articles (not inclusive)
3711            * @return the range of matching journal articles
3712            * @throws SystemException if a system exception occurred
3713            */
3714            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3715                    long groupId, java.lang.String layoutUuid, int start, int end)
3716                    throws com.liferay.portal.kernel.exception.SystemException {
3717                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
3718            }
3719    
3720            /**
3721            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3722            *
3723            * <p>
3724            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3725            * </p>
3726            *
3727            * @param groupId the group ID
3728            * @param layoutUuid the layout uuid
3729            * @param start the lower bound of the range of journal articles
3730            * @param end the upper bound of the range of journal articles (not inclusive)
3731            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3732            * @return the ordered range of matching journal articles
3733            * @throws SystemException if a system exception occurred
3734            */
3735            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3736                    long groupId, java.lang.String layoutUuid, int start, int end,
3737                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3738                    throws com.liferay.portal.kernel.exception.SystemException {
3739                    return getPersistence()
3740                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
3741            }
3742    
3743            /**
3744            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3745            *
3746            * @param groupId the group ID
3747            * @param layoutUuid the layout uuid
3748            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3749            * @return the first matching journal article
3750            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3751            * @throws SystemException if a system exception occurred
3752            */
3753            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
3754                    long groupId, java.lang.String layoutUuid,
3755                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3756                    throws com.liferay.portal.kernel.exception.SystemException,
3757                            com.liferay.portlet.journal.NoSuchArticleException {
3758                    return getPersistence()
3759                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
3760            }
3761    
3762            /**
3763            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3764            *
3765            * @param groupId the group ID
3766            * @param layoutUuid the layout uuid
3767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3768            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3769            * @throws SystemException if a system exception occurred
3770            */
3771            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
3772                    long groupId, java.lang.String layoutUuid,
3773                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3774                    throws com.liferay.portal.kernel.exception.SystemException {
3775                    return getPersistence()
3776                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
3777            }
3778    
3779            /**
3780            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3781            *
3782            * @param groupId the group ID
3783            * @param layoutUuid the layout uuid
3784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3785            * @return the last matching journal article
3786            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3787            * @throws SystemException if a system exception occurred
3788            */
3789            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
3790                    long groupId, java.lang.String layoutUuid,
3791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3792                    throws com.liferay.portal.kernel.exception.SystemException,
3793                            com.liferay.portlet.journal.NoSuchArticleException {
3794                    return getPersistence()
3795                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
3796            }
3797    
3798            /**
3799            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3800            *
3801            * @param groupId the group ID
3802            * @param layoutUuid the layout uuid
3803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3804            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3805            * @throws SystemException if a system exception occurred
3806            */
3807            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
3808                    long groupId, java.lang.String layoutUuid,
3809                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3810                    throws com.liferay.portal.kernel.exception.SystemException {
3811                    return getPersistence()
3812                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
3813            }
3814    
3815            /**
3816            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3817            *
3818            * @param id the primary key of the current journal article
3819            * @param groupId the group ID
3820            * @param layoutUuid the layout uuid
3821            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3822            * @return the previous, current, and next journal article
3823            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3824            * @throws SystemException if a system exception occurred
3825            */
3826            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
3827                    long id, long groupId, java.lang.String layoutUuid,
3828                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3829                    throws com.liferay.portal.kernel.exception.SystemException,
3830                            com.liferay.portlet.journal.NoSuchArticleException {
3831                    return getPersistence()
3832                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
3833                            orderByComparator);
3834            }
3835    
3836            /**
3837            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3838            *
3839            * @param groupId the group ID
3840            * @param layoutUuid the layout uuid
3841            * @return the matching journal articles that the user has permission to view
3842            * @throws SystemException if a system exception occurred
3843            */
3844            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3845                    long groupId, java.lang.String layoutUuid)
3846                    throws com.liferay.portal.kernel.exception.SystemException {
3847                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
3848            }
3849    
3850            /**
3851            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3852            *
3853            * <p>
3854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3855            * </p>
3856            *
3857            * @param groupId the group ID
3858            * @param layoutUuid the layout uuid
3859            * @param start the lower bound of the range of journal articles
3860            * @param end the upper bound of the range of journal articles (not inclusive)
3861            * @return the range of matching journal articles that the user has permission to view
3862            * @throws SystemException if a system exception occurred
3863            */
3864            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3865                    long groupId, java.lang.String layoutUuid, int start, int end)
3866                    throws com.liferay.portal.kernel.exception.SystemException {
3867                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
3868            }
3869    
3870            /**
3871            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
3872            *
3873            * <p>
3874            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3875            * </p>
3876            *
3877            * @param groupId the group ID
3878            * @param layoutUuid the layout uuid
3879            * @param start the lower bound of the range of journal articles
3880            * @param end the upper bound of the range of journal articles (not inclusive)
3881            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3882            * @return the ordered range of matching journal articles that the user has permission to view
3883            * @throws SystemException if a system exception occurred
3884            */
3885            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3886                    long groupId, java.lang.String layoutUuid, int start, int end,
3887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3888                    throws com.liferay.portal.kernel.exception.SystemException {
3889                    return getPersistence()
3890                                       .filterFindByG_L(groupId, layoutUuid, start, end,
3891                            orderByComparator);
3892            }
3893    
3894            /**
3895            * 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;.
3896            *
3897            * @param id the primary key of the current journal article
3898            * @param groupId the group ID
3899            * @param layoutUuid the layout uuid
3900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3901            * @return the previous, current, and next journal article
3902            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3903            * @throws SystemException if a system exception occurred
3904            */
3905            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
3906                    long id, long groupId, java.lang.String layoutUuid,
3907                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3908                    throws com.liferay.portal.kernel.exception.SystemException,
3909                            com.liferay.portlet.journal.NoSuchArticleException {
3910                    return getPersistence()
3911                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
3912                            orderByComparator);
3913            }
3914    
3915            /**
3916            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
3917            *
3918            * @param groupId the group ID
3919            * @param layoutUuid the layout uuid
3920            * @throws SystemException if a system exception occurred
3921            */
3922            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
3923                    throws com.liferay.portal.kernel.exception.SystemException {
3924                    getPersistence().removeByG_L(groupId, layoutUuid);
3925            }
3926    
3927            /**
3928            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
3929            *
3930            * @param groupId the group ID
3931            * @param layoutUuid the layout uuid
3932            * @return the number of matching journal articles
3933            * @throws SystemException if a system exception occurred
3934            */
3935            public static int countByG_L(long groupId, java.lang.String layoutUuid)
3936                    throws com.liferay.portal.kernel.exception.SystemException {
3937                    return getPersistence().countByG_L(groupId, layoutUuid);
3938            }
3939    
3940            /**
3941            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3942            *
3943            * @param groupId the group ID
3944            * @param layoutUuid the layout uuid
3945            * @return the number of matching journal articles that the user has permission to view
3946            * @throws SystemException if a system exception occurred
3947            */
3948            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
3949                    throws com.liferay.portal.kernel.exception.SystemException {
3950                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
3951            }
3952    
3953            /**
3954            * Returns all the journal articles where groupId = &#63; and status = &#63;.
3955            *
3956            * @param groupId the group ID
3957            * @param status the status
3958            * @return the matching journal articles
3959            * @throws SystemException if a system exception occurred
3960            */
3961            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
3962                    long groupId, int status)
3963                    throws com.liferay.portal.kernel.exception.SystemException {
3964                    return getPersistence().findByG_ST(groupId, status);
3965            }
3966    
3967            /**
3968            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
3969            *
3970            * <p>
3971            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3972            * </p>
3973            *
3974            * @param groupId the group ID
3975            * @param status the status
3976            * @param start the lower bound of the range of journal articles
3977            * @param end the upper bound of the range of journal articles (not inclusive)
3978            * @return the range of matching journal articles
3979            * @throws SystemException if a system exception occurred
3980            */
3981            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
3982                    long groupId, int status, int start, int end)
3983                    throws com.liferay.portal.kernel.exception.SystemException {
3984                    return getPersistence().findByG_ST(groupId, status, start, end);
3985            }
3986    
3987            /**
3988            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
3989            *
3990            * <p>
3991            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3992            * </p>
3993            *
3994            * @param groupId the group ID
3995            * @param status the status
3996            * @param start the lower bound of the range of journal articles
3997            * @param end the upper bound of the range of journal articles (not inclusive)
3998            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3999            * @return the ordered range of matching journal articles
4000            * @throws SystemException if a system exception occurred
4001            */
4002            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4003                    long groupId, int status, int start, int end,
4004                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4005                    throws com.liferay.portal.kernel.exception.SystemException {
4006                    return getPersistence()
4007                                       .findByG_ST(groupId, status, start, end, orderByComparator);
4008            }
4009    
4010            /**
4011            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4012            *
4013            * @param groupId the group ID
4014            * @param status the status
4015            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4016            * @return the first matching journal article
4017            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4018            * @throws SystemException if a system exception occurred
4019            */
4020            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
4021                    long groupId, int status,
4022                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4023                    throws com.liferay.portal.kernel.exception.SystemException,
4024                            com.liferay.portlet.journal.NoSuchArticleException {
4025                    return getPersistence()
4026                                       .findByG_ST_First(groupId, status, orderByComparator);
4027            }
4028    
4029            /**
4030            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4031            *
4032            * @param groupId the group ID
4033            * @param status the status
4034            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4035            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4036            * @throws SystemException if a system exception occurred
4037            */
4038            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
4039                    long groupId, int status,
4040                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4041                    throws com.liferay.portal.kernel.exception.SystemException {
4042                    return getPersistence()
4043                                       .fetchByG_ST_First(groupId, status, orderByComparator);
4044            }
4045    
4046            /**
4047            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4048            *
4049            * @param groupId the group ID
4050            * @param status the status
4051            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4052            * @return the last matching journal article
4053            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4054            * @throws SystemException if a system exception occurred
4055            */
4056            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
4057                    long groupId, int status,
4058                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4059                    throws com.liferay.portal.kernel.exception.SystemException,
4060                            com.liferay.portlet.journal.NoSuchArticleException {
4061                    return getPersistence()
4062                                       .findByG_ST_Last(groupId, status, orderByComparator);
4063            }
4064    
4065            /**
4066            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4067            *
4068            * @param groupId the group ID
4069            * @param status the status
4070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4071            * @return the last 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_ST_Last(
4075                    long groupId, int status,
4076                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4077                    throws com.liferay.portal.kernel.exception.SystemException {
4078                    return getPersistence()
4079                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
4080            }
4081    
4082            /**
4083            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
4084            *
4085            * @param id the primary key of the current journal article
4086            * @param groupId the group ID
4087            * @param status the status
4088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4089            * @return the previous, current, and next journal article
4090            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4091            * @throws SystemException if a system exception occurred
4092            */
4093            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
4094                    long id, long groupId, int status,
4095                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4096                    throws com.liferay.portal.kernel.exception.SystemException,
4097                            com.liferay.portlet.journal.NoSuchArticleException {
4098                    return getPersistence()
4099                                       .findByG_ST_PrevAndNext(id, groupId, status,
4100                            orderByComparator);
4101            }
4102    
4103            /**
4104            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4105            *
4106            * @param groupId the group ID
4107            * @param status the status
4108            * @return the matching journal articles that the user has permission to view
4109            * @throws SystemException if a system exception occurred
4110            */
4111            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4112                    long groupId, int status)
4113                    throws com.liferay.portal.kernel.exception.SystemException {
4114                    return getPersistence().filterFindByG_ST(groupId, status);
4115            }
4116    
4117            /**
4118            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4119            *
4120            * <p>
4121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4122            * </p>
4123            *
4124            * @param groupId the group ID
4125            * @param status the status
4126            * @param start the lower bound of the range of journal articles
4127            * @param end the upper bound of the range of journal articles (not inclusive)
4128            * @return the range of matching journal articles that the user has permission to view
4129            * @throws SystemException if a system exception occurred
4130            */
4131            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4132                    long groupId, int status, int start, int end)
4133                    throws com.liferay.portal.kernel.exception.SystemException {
4134                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
4135            }
4136    
4137            /**
4138            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
4139            *
4140            * <p>
4141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4142            * </p>
4143            *
4144            * @param groupId the group ID
4145            * @param status the status
4146            * @param start the lower bound of the range of journal articles
4147            * @param end the upper bound of the range of journal articles (not inclusive)
4148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4149            * @return the ordered range of matching journal articles that the user has permission to view
4150            * @throws SystemException if a system exception occurred
4151            */
4152            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4153                    long groupId, int status, int start, int end,
4154                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4155                    throws com.liferay.portal.kernel.exception.SystemException {
4156                    return getPersistence()
4157                                       .filterFindByG_ST(groupId, status, start, end,
4158                            orderByComparator);
4159            }
4160    
4161            /**
4162            * 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;.
4163            *
4164            * @param id the primary key of the current journal article
4165            * @param groupId the group ID
4166            * @param status the status
4167            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4168            * @return the previous, current, and next journal article
4169            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4170            * @throws SystemException if a system exception occurred
4171            */
4172            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
4173                    long id, long groupId, int status,
4174                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4175                    throws com.liferay.portal.kernel.exception.SystemException,
4176                            com.liferay.portlet.journal.NoSuchArticleException {
4177                    return getPersistence()
4178                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
4179                            orderByComparator);
4180            }
4181    
4182            /**
4183            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4184            *
4185            * @param groupId the group ID
4186            * @param status the status
4187            * @throws SystemException if a system exception occurred
4188            */
4189            public static void removeByG_ST(long groupId, int status)
4190                    throws com.liferay.portal.kernel.exception.SystemException {
4191                    getPersistence().removeByG_ST(groupId, status);
4192            }
4193    
4194            /**
4195            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4196            *
4197            * @param groupId the group ID
4198            * @param status the status
4199            * @return the number of matching journal articles
4200            * @throws SystemException if a system exception occurred
4201            */
4202            public static int countByG_ST(long groupId, int status)
4203                    throws com.liferay.portal.kernel.exception.SystemException {
4204                    return getPersistence().countByG_ST(groupId, status);
4205            }
4206    
4207            /**
4208            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4209            *
4210            * @param groupId the group ID
4211            * @param status the status
4212            * @return the number of matching journal articles that the user has permission to view
4213            * @throws SystemException if a system exception occurred
4214            */
4215            public static int filterCountByG_ST(long groupId, int status)
4216                    throws com.liferay.portal.kernel.exception.SystemException {
4217                    return getPersistence().filterCountByG_ST(groupId, status);
4218            }
4219    
4220            /**
4221            * Returns all the journal articles where companyId = &#63; and version = &#63;.
4222            *
4223            * @param companyId the company ID
4224            * @param version the version
4225            * @return the matching journal articles
4226            * @throws SystemException if a system exception occurred
4227            */
4228            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4229                    long companyId, double version)
4230                    throws com.liferay.portal.kernel.exception.SystemException {
4231                    return getPersistence().findByC_V(companyId, version);
4232            }
4233    
4234            /**
4235            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4236            *
4237            * <p>
4238            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4239            * </p>
4240            *
4241            * @param companyId the company ID
4242            * @param version the version
4243            * @param start the lower bound of the range of journal articles
4244            * @param end the upper bound of the range of journal articles (not inclusive)
4245            * @return the range of matching journal articles
4246            * @throws SystemException if a system exception occurred
4247            */
4248            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4249                    long companyId, double version, int start, int end)
4250                    throws com.liferay.portal.kernel.exception.SystemException {
4251                    return getPersistence().findByC_V(companyId, version, start, end);
4252            }
4253    
4254            /**
4255            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
4256            *
4257            * <p>
4258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4259            * </p>
4260            *
4261            * @param companyId the company ID
4262            * @param version the version
4263            * @param start the lower bound of the range of journal articles
4264            * @param end the upper bound of the range of journal articles (not inclusive)
4265            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4266            * @return the ordered range of matching journal articles
4267            * @throws SystemException if a system exception occurred
4268            */
4269            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4270                    long companyId, double version, int start, int end,
4271                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4272                    throws com.liferay.portal.kernel.exception.SystemException {
4273                    return getPersistence()
4274                                       .findByC_V(companyId, version, start, end, orderByComparator);
4275            }
4276    
4277            /**
4278            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4279            *
4280            * @param companyId the company ID
4281            * @param version the version
4282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4283            * @return the first matching journal article
4284            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4285            * @throws SystemException if a system exception occurred
4286            */
4287            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
4288                    long companyId, double version,
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                                       .findByC_V_First(companyId, version, orderByComparator);
4294            }
4295    
4296            /**
4297            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4298            *
4299            * @param companyId the company ID
4300            * @param version the version
4301            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4302            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4303            * @throws SystemException if a system exception occurred
4304            */
4305            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
4306                    long companyId, double version,
4307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4308                    throws com.liferay.portal.kernel.exception.SystemException {
4309                    return getPersistence()
4310                                       .fetchByC_V_First(companyId, version, orderByComparator);
4311            }
4312    
4313            /**
4314            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4315            *
4316            * @param companyId the company ID
4317            * @param version the version
4318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4319            * @return the last matching journal article
4320            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4321            * @throws SystemException if a system exception occurred
4322            */
4323            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
4324                    long companyId, double version,
4325                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4326                    throws com.liferay.portal.kernel.exception.SystemException,
4327                            com.liferay.portlet.journal.NoSuchArticleException {
4328                    return getPersistence()
4329                                       .findByC_V_Last(companyId, version, orderByComparator);
4330            }
4331    
4332            /**
4333            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4334            *
4335            * @param companyId the company ID
4336            * @param version the version
4337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4338            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4339            * @throws SystemException if a system exception occurred
4340            */
4341            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
4342                    long companyId, double version,
4343                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4344                    throws com.liferay.portal.kernel.exception.SystemException {
4345                    return getPersistence()
4346                                       .fetchByC_V_Last(companyId, version, orderByComparator);
4347            }
4348    
4349            /**
4350            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
4351            *
4352            * @param id the primary key of the current journal article
4353            * @param companyId the company ID
4354            * @param version the version
4355            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4356            * @return the previous, current, and next journal article
4357            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4358            * @throws SystemException if a system exception occurred
4359            */
4360            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
4361                    long id, long companyId, double version,
4362                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4363                    throws com.liferay.portal.kernel.exception.SystemException,
4364                            com.liferay.portlet.journal.NoSuchArticleException {
4365                    return getPersistence()
4366                                       .findByC_V_PrevAndNext(id, companyId, version,
4367                            orderByComparator);
4368            }
4369    
4370            /**
4371            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4372            *
4373            * @param companyId the company ID
4374            * @param version the version
4375            * @throws SystemException if a system exception occurred
4376            */
4377            public static void removeByC_V(long companyId, double version)
4378                    throws com.liferay.portal.kernel.exception.SystemException {
4379                    getPersistence().removeByC_V(companyId, version);
4380            }
4381    
4382            /**
4383            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4384            *
4385            * @param companyId the company ID
4386            * @param version the version
4387            * @return the number of matching journal articles
4388            * @throws SystemException if a system exception occurred
4389            */
4390            public static int countByC_V(long companyId, double version)
4391                    throws com.liferay.portal.kernel.exception.SystemException {
4392                    return getPersistence().countByC_V(companyId, version);
4393            }
4394    
4395            /**
4396            * Returns all the journal articles where companyId = &#63; and status = &#63;.
4397            *
4398            * @param companyId the company ID
4399            * @param status the status
4400            * @return the matching journal articles
4401            * @throws SystemException if a system exception occurred
4402            */
4403            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4404                    long companyId, int status)
4405                    throws com.liferay.portal.kernel.exception.SystemException {
4406                    return getPersistence().findByC_ST(companyId, status);
4407            }
4408    
4409            /**
4410            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
4411            *
4412            * <p>
4413            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4414            * </p>
4415            *
4416            * @param companyId the company ID
4417            * @param status the status
4418            * @param start the lower bound of the range of journal articles
4419            * @param end the upper bound of the range of journal articles (not inclusive)
4420            * @return the range of matching journal articles
4421            * @throws SystemException if a system exception occurred
4422            */
4423            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4424                    long companyId, int status, int start, int end)
4425                    throws com.liferay.portal.kernel.exception.SystemException {
4426                    return getPersistence().findByC_ST(companyId, status, start, end);
4427            }
4428    
4429            /**
4430            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
4431            *
4432            * <p>
4433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4434            * </p>
4435            *
4436            * @param companyId the company ID
4437            * @param status the status
4438            * @param start the lower bound of the range of journal articles
4439            * @param end the upper bound of the range of journal articles (not inclusive)
4440            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4441            * @return the ordered range of matching journal articles
4442            * @throws SystemException if a system exception occurred
4443            */
4444            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4445                    long companyId, int status, int start, int end,
4446                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4447                    throws com.liferay.portal.kernel.exception.SystemException {
4448                    return getPersistence()
4449                                       .findByC_ST(companyId, status, start, end, orderByComparator);
4450            }
4451    
4452            /**
4453            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4454            *
4455            * @param companyId the company ID
4456            * @param status the status
4457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4458            * @return the first matching journal article
4459            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4460            * @throws SystemException if a system exception occurred
4461            */
4462            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
4463                    long companyId, int status,
4464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4465                    throws com.liferay.portal.kernel.exception.SystemException,
4466                            com.liferay.portlet.journal.NoSuchArticleException {
4467                    return getPersistence()
4468                                       .findByC_ST_First(companyId, status, orderByComparator);
4469            }
4470    
4471            /**
4472            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4473            *
4474            * @param companyId the company ID
4475            * @param status the status
4476            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4477            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4478            * @throws SystemException if a system exception occurred
4479            */
4480            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
4481                    long companyId, int status,
4482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4483                    throws com.liferay.portal.kernel.exception.SystemException {
4484                    return getPersistence()
4485                                       .fetchByC_ST_First(companyId, status, orderByComparator);
4486            }
4487    
4488            /**
4489            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4490            *
4491            * @param companyId the company ID
4492            * @param status the status
4493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4494            * @return the last matching journal article
4495            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4496            * @throws SystemException if a system exception occurred
4497            */
4498            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
4499                    long companyId, int status,
4500                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4501                    throws com.liferay.portal.kernel.exception.SystemException,
4502                            com.liferay.portlet.journal.NoSuchArticleException {
4503                    return getPersistence()
4504                                       .findByC_ST_Last(companyId, status, orderByComparator);
4505            }
4506    
4507            /**
4508            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4509            *
4510            * @param companyId the company ID
4511            * @param status the status
4512            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4513            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4514            * @throws SystemException if a system exception occurred
4515            */
4516            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
4517                    long companyId, int status,
4518                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4519                    throws com.liferay.portal.kernel.exception.SystemException {
4520                    return getPersistence()
4521                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
4522            }
4523    
4524            /**
4525            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
4526            *
4527            * @param id the primary key of the current journal article
4528            * @param companyId the company ID
4529            * @param status the status
4530            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4531            * @return the previous, current, and next journal article
4532            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4533            * @throws SystemException if a system exception occurred
4534            */
4535            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
4536                    long id, long companyId, int status,
4537                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4538                    throws com.liferay.portal.kernel.exception.SystemException,
4539                            com.liferay.portlet.journal.NoSuchArticleException {
4540                    return getPersistence()
4541                                       .findByC_ST_PrevAndNext(id, companyId, status,
4542                            orderByComparator);
4543            }
4544    
4545            /**
4546            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4547            *
4548            * @param companyId the company ID
4549            * @param status the status
4550            * @throws SystemException if a system exception occurred
4551            */
4552            public static void removeByC_ST(long companyId, int status)
4553                    throws com.liferay.portal.kernel.exception.SystemException {
4554                    getPersistence().removeByC_ST(companyId, status);
4555            }
4556    
4557            /**
4558            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4559            *
4560            * @param companyId the company ID
4561            * @param status the status
4562            * @return the number of matching journal articles
4563            * @throws SystemException if a system exception occurred
4564            */
4565            public static int countByC_ST(long companyId, int status)
4566                    throws com.liferay.portal.kernel.exception.SystemException {
4567                    return getPersistence().countByC_ST(companyId, status);
4568            }
4569    
4570            /**
4571            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4572            *
4573            * @param groupId the group ID
4574            * @param folderId the folder ID
4575            * @param status the status
4576            * @return the matching journal articles
4577            * @throws SystemException if a system exception occurred
4578            */
4579            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4580                    long groupId, long folderId, int status)
4581                    throws com.liferay.portal.kernel.exception.SystemException {
4582                    return getPersistence().findByG_F_ST(groupId, folderId, status);
4583            }
4584    
4585            /**
4586            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4587            *
4588            * <p>
4589            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4590            * </p>
4591            *
4592            * @param groupId the group ID
4593            * @param folderId the folder ID
4594            * @param status the status
4595            * @param start the lower bound of the range of journal articles
4596            * @param end the upper bound of the range of journal articles (not inclusive)
4597            * @return the range of matching journal articles
4598            * @throws SystemException if a system exception occurred
4599            */
4600            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4601                    long groupId, long folderId, int status, int start, int end)
4602                    throws com.liferay.portal.kernel.exception.SystemException {
4603                    return getPersistence()
4604                                       .findByG_F_ST(groupId, folderId, status, start, end);
4605            }
4606    
4607            /**
4608            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4609            *
4610            * <p>
4611            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4612            * </p>
4613            *
4614            * @param groupId the group ID
4615            * @param folderId the folder ID
4616            * @param status the status
4617            * @param start the lower bound of the range of journal articles
4618            * @param end the upper bound of the range of journal articles (not inclusive)
4619            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4620            * @return the ordered range of matching journal articles
4621            * @throws SystemException if a system exception occurred
4622            */
4623            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4624                    long groupId, long folderId, int status, int start, int end,
4625                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4626                    throws com.liferay.portal.kernel.exception.SystemException {
4627                    return getPersistence()
4628                                       .findByG_F_ST(groupId, folderId, status, start, end,
4629                            orderByComparator);
4630            }
4631    
4632            /**
4633            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4634            *
4635            * @param groupId the group ID
4636            * @param folderId the folder ID
4637            * @param status the status
4638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4639            * @return the first matching journal article
4640            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4641            * @throws SystemException if a system exception occurred
4642            */
4643            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
4644                    long groupId, long folderId, int status,
4645                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4646                    throws com.liferay.portal.kernel.exception.SystemException,
4647                            com.liferay.portlet.journal.NoSuchArticleException {
4648                    return getPersistence()
4649                                       .findByG_F_ST_First(groupId, folderId, status,
4650                            orderByComparator);
4651            }
4652    
4653            /**
4654            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4655            *
4656            * @param groupId the group ID
4657            * @param folderId the folder ID
4658            * @param status the status
4659            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4660            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4661            * @throws SystemException if a system exception occurred
4662            */
4663            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
4664                    long groupId, long folderId, int status,
4665                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4666                    throws com.liferay.portal.kernel.exception.SystemException {
4667                    return getPersistence()
4668                                       .fetchByG_F_ST_First(groupId, folderId, status,
4669                            orderByComparator);
4670            }
4671    
4672            /**
4673            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4674            *
4675            * @param groupId the group ID
4676            * @param folderId the folder ID
4677            * @param status the status
4678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4679            * @return the last 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 findByG_F_ST_Last(
4684                    long groupId, long folderId, 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                                       .findByG_F_ST_Last(groupId, folderId, status,
4690                            orderByComparator);
4691            }
4692    
4693            /**
4694            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4695            *
4696            * @param groupId the group ID
4697            * @param folderId the folder ID
4698            * @param status the status
4699            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4700            * @return the last 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 fetchByG_F_ST_Last(
4704                    long groupId, long folderId, int status,
4705                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4706                    throws com.liferay.portal.kernel.exception.SystemException {
4707                    return getPersistence()
4708                                       .fetchByG_F_ST_Last(groupId, folderId, status,
4709                            orderByComparator);
4710            }
4711    
4712            /**
4713            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4714            *
4715            * @param id the primary key of the current journal article
4716            * @param groupId the group ID
4717            * @param folderId the folder ID
4718            * @param status the status
4719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4720            * @return the previous, current, and next journal article
4721            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4722            * @throws SystemException if a system exception occurred
4723            */
4724            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
4725                    long id, long groupId, long folderId, int status,
4726                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4727                    throws com.liferay.portal.kernel.exception.SystemException,
4728                            com.liferay.portlet.journal.NoSuchArticleException {
4729                    return getPersistence()
4730                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
4731                            orderByComparator);
4732            }
4733    
4734            /**
4735            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4736            *
4737            * @param groupId the group ID
4738            * @param folderId the folder ID
4739            * @param status the status
4740            * @return the matching journal articles that the user has permission to view
4741            * @throws SystemException if a system exception occurred
4742            */
4743            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4744                    long groupId, long folderId, int status)
4745                    throws com.liferay.portal.kernel.exception.SystemException {
4746                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
4747            }
4748    
4749            /**
4750            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4751            *
4752            * <p>
4753            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4754            * </p>
4755            *
4756            * @param groupId the group ID
4757            * @param folderId the folder ID
4758            * @param status the status
4759            * @param start the lower bound of the range of journal articles
4760            * @param end the upper bound of the range of journal articles (not inclusive)
4761            * @return the range of matching journal articles that the user has permission to view
4762            * @throws SystemException if a system exception occurred
4763            */
4764            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4765                    long groupId, long folderId, int status, int start, int end)
4766                    throws com.liferay.portal.kernel.exception.SystemException {
4767                    return getPersistence()
4768                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
4769            }
4770    
4771            /**
4772            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4773            *
4774            * <p>
4775            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4776            * </p>
4777            *
4778            * @param groupId the group ID
4779            * @param folderId the folder ID
4780            * @param status the status
4781            * @param start the lower bound of the range of journal articles
4782            * @param end the upper bound of the range of journal articles (not inclusive)
4783            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4784            * @return the ordered range of matching journal articles that the user has permission to view
4785            * @throws SystemException if a system exception occurred
4786            */
4787            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4788                    long groupId, long folderId, int status, int start, int end,
4789                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4790                    throws com.liferay.portal.kernel.exception.SystemException {
4791                    return getPersistence()
4792                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
4793                            orderByComparator);
4794            }
4795    
4796            /**
4797            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4798            *
4799            * @param id the primary key of the current journal article
4800            * @param groupId the group ID
4801            * @param folderId the folder ID
4802            * @param status the status
4803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4804            * @return the previous, current, and next journal article
4805            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4806            * @throws SystemException if a system exception occurred
4807            */
4808            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
4809                    long id, long groupId, long folderId, int status,
4810                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4811                    throws com.liferay.portal.kernel.exception.SystemException,
4812                            com.liferay.portlet.journal.NoSuchArticleException {
4813                    return getPersistence()
4814                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
4815                            status, orderByComparator);
4816            }
4817    
4818            /**
4819            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
4820            *
4821            * @param groupId the group ID
4822            * @param folderId the folder ID
4823            * @param statuses the statuses
4824            * @return the matching journal articles that the user has permission to view
4825            * @throws SystemException if a system exception occurred
4826            */
4827            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4828                    long groupId, long folderId, int[] statuses)
4829                    throws com.liferay.portal.kernel.exception.SystemException {
4830                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
4831            }
4832    
4833            /**
4834            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
4835            *
4836            * <p>
4837            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4838            * </p>
4839            *
4840            * @param groupId the group ID
4841            * @param folderId the folder ID
4842            * @param statuses the statuses
4843            * @param start the lower bound of the range of journal articles
4844            * @param end the upper bound of the range of journal articles (not inclusive)
4845            * @return the range of matching journal articles that the user has permission to view
4846            * @throws SystemException if a system exception occurred
4847            */
4848            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4849                    long groupId, long folderId, int[] statuses, int start, int end)
4850                    throws com.liferay.portal.kernel.exception.SystemException {
4851                    return getPersistence()
4852                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
4853            }
4854    
4855            /**
4856            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
4857            *
4858            * <p>
4859            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4860            * </p>
4861            *
4862            * @param groupId the group ID
4863            * @param folderId the folder ID
4864            * @param statuses the statuses
4865            * @param start the lower bound of the range of journal articles
4866            * @param end the upper bound of the range of journal articles (not inclusive)
4867            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4868            * @return the ordered range of matching journal articles that the user has permission to view
4869            * @throws SystemException if a system exception occurred
4870            */
4871            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4872                    long groupId, long folderId, int[] statuses, int start, int end,
4873                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4874                    throws com.liferay.portal.kernel.exception.SystemException {
4875                    return getPersistence()
4876                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
4877                            orderByComparator);
4878            }
4879    
4880            /**
4881            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4882            *
4883            * <p>
4884            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4885            * </p>
4886            *
4887            * @param groupId the group ID
4888            * @param folderId the folder ID
4889            * @param statuses the statuses
4890            * @return the matching journal articles
4891            * @throws SystemException if a system exception occurred
4892            */
4893            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4894                    long groupId, long folderId, int[] statuses)
4895                    throws com.liferay.portal.kernel.exception.SystemException {
4896                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
4897            }
4898    
4899            /**
4900            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4901            *
4902            * <p>
4903            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4904            * </p>
4905            *
4906            * @param groupId the group ID
4907            * @param folderId the folder ID
4908            * @param statuses the statuses
4909            * @param start the lower bound of the range of journal articles
4910            * @param end the upper bound of the range of journal articles (not inclusive)
4911            * @return the range of matching journal articles
4912            * @throws SystemException if a system exception occurred
4913            */
4914            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4915                    long groupId, long folderId, int[] statuses, int start, int end)
4916                    throws com.liferay.portal.kernel.exception.SystemException {
4917                    return getPersistence()
4918                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
4919            }
4920    
4921            /**
4922            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4923            *
4924            * <p>
4925            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4926            * </p>
4927            *
4928            * @param groupId the group ID
4929            * @param folderId the folder ID
4930            * @param statuses the statuses
4931            * @param start the lower bound of the range of journal articles
4932            * @param end the upper bound of the range of journal articles (not inclusive)
4933            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4934            * @return the ordered range of matching journal articles
4935            * @throws SystemException if a system exception occurred
4936            */
4937            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4938                    long groupId, long folderId, int[] statuses, int start, int end,
4939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4940                    throws com.liferay.portal.kernel.exception.SystemException {
4941                    return getPersistence()
4942                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
4943                            orderByComparator);
4944            }
4945    
4946            /**
4947            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
4948            *
4949            * @param groupId the group ID
4950            * @param folderId the folder ID
4951            * @param status the status
4952            * @throws SystemException if a system exception occurred
4953            */
4954            public static void removeByG_F_ST(long groupId, long folderId, int status)
4955                    throws com.liferay.portal.kernel.exception.SystemException {
4956                    getPersistence().removeByG_F_ST(groupId, folderId, status);
4957            }
4958    
4959            /**
4960            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4961            *
4962            * @param groupId the group ID
4963            * @param folderId the folder ID
4964            * @param status the status
4965            * @return the number of matching journal articles
4966            * @throws SystemException if a system exception occurred
4967            */
4968            public static int countByG_F_ST(long groupId, long folderId, int status)
4969                    throws com.liferay.portal.kernel.exception.SystemException {
4970                    return getPersistence().countByG_F_ST(groupId, folderId, status);
4971            }
4972    
4973            /**
4974            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4975            *
4976            * @param groupId the group ID
4977            * @param folderId the folder ID
4978            * @param statuses the statuses
4979            * @return the number of matching journal articles
4980            * @throws SystemException if a system exception occurred
4981            */
4982            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
4983                    throws com.liferay.portal.kernel.exception.SystemException {
4984                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
4985            }
4986    
4987            /**
4988            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4989            *
4990            * @param groupId the group ID
4991            * @param folderId the folder ID
4992            * @param status the status
4993            * @return the number of matching journal articles that the user has permission to view
4994            * @throws SystemException if a system exception occurred
4995            */
4996            public static int filterCountByG_F_ST(long groupId, long folderId,
4997                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4998                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
4999            }
5000    
5001            /**
5002            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5003            *
5004            * @param groupId the group ID
5005            * @param folderId the folder ID
5006            * @param statuses the statuses
5007            * @return the number of matching journal articles that the user has permission to view
5008            * @throws SystemException if a system exception occurred
5009            */
5010            public static int filterCountByG_F_ST(long groupId, long folderId,
5011                    int[] statuses)
5012                    throws com.liferay.portal.kernel.exception.SystemException {
5013                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
5014            }
5015    
5016            /**
5017            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5018            *
5019            * @param groupId the group ID
5020            * @param folderId the folder ID
5021            * @param status the status
5022            * @return the matching journal articles
5023            * @throws SystemException if a system exception occurred
5024            */
5025            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_NotST(
5026                    long groupId, long folderId, int status)
5027                    throws com.liferay.portal.kernel.exception.SystemException {
5028                    return getPersistence().findByG_F_NotST(groupId, folderId, status);
5029            }
5030    
5031            /**
5032            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5033            *
5034            * <p>
5035            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5036            * </p>
5037            *
5038            * @param groupId the group ID
5039            * @param folderId the folder ID
5040            * @param status the status
5041            * @param start the lower bound of the range of journal articles
5042            * @param end the upper bound of the range of journal articles (not inclusive)
5043            * @return the range of matching journal articles
5044            * @throws SystemException if a system exception occurred
5045            */
5046            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_NotST(
5047                    long groupId, long folderId, int status, int start, int end)
5048                    throws com.liferay.portal.kernel.exception.SystemException {
5049                    return getPersistence()
5050                                       .findByG_F_NotST(groupId, folderId, status, start, end);
5051            }
5052    
5053            /**
5054            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5055            *
5056            * <p>
5057            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5058            * </p>
5059            *
5060            * @param groupId the group ID
5061            * @param folderId the folder ID
5062            * @param status the status
5063            * @param start the lower bound of the range of journal articles
5064            * @param end the upper bound of the range of journal articles (not inclusive)
5065            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5066            * @return the ordered range of matching journal articles
5067            * @throws SystemException if a system exception occurred
5068            */
5069            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_NotST(
5070                    long groupId, long folderId, int status, int start, int end,
5071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5072                    throws com.liferay.portal.kernel.exception.SystemException {
5073                    return getPersistence()
5074                                       .findByG_F_NotST(groupId, folderId, status, start, end,
5075                            orderByComparator);
5076            }
5077    
5078            /**
5079            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5080            *
5081            * @param groupId the group ID
5082            * @param folderId the folder ID
5083            * @param status the status
5084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5085            * @return the first matching journal article
5086            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5087            * @throws SystemException if a system exception occurred
5088            */
5089            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_NotST_First(
5090                    long groupId, long folderId, int status,
5091                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5092                    throws com.liferay.portal.kernel.exception.SystemException,
5093                            com.liferay.portlet.journal.NoSuchArticleException {
5094                    return getPersistence()
5095                                       .findByG_F_NotST_First(groupId, folderId, status,
5096                            orderByComparator);
5097            }
5098    
5099            /**
5100            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5101            *
5102            * @param groupId the group ID
5103            * @param folderId the folder ID
5104            * @param status the status
5105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5106            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5107            * @throws SystemException if a system exception occurred
5108            */
5109            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_NotST_First(
5110                    long groupId, long folderId, int status,
5111                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5112                    throws com.liferay.portal.kernel.exception.SystemException {
5113                    return getPersistence()
5114                                       .fetchByG_F_NotST_First(groupId, folderId, status,
5115                            orderByComparator);
5116            }
5117    
5118            /**
5119            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5120            *
5121            * @param groupId the group ID
5122            * @param folderId the folder ID
5123            * @param status the status
5124            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5125            * @return the last matching journal article
5126            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5127            * @throws SystemException if a system exception occurred
5128            */
5129            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_NotST_Last(
5130                    long groupId, long folderId, int status,
5131                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5132                    throws com.liferay.portal.kernel.exception.SystemException,
5133                            com.liferay.portlet.journal.NoSuchArticleException {
5134                    return getPersistence()
5135                                       .findByG_F_NotST_Last(groupId, folderId, status,
5136                            orderByComparator);
5137            }
5138    
5139            /**
5140            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5141            *
5142            * @param groupId the group ID
5143            * @param folderId the folder ID
5144            * @param status the status
5145            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5146            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5147            * @throws SystemException if a system exception occurred
5148            */
5149            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_NotST_Last(
5150                    long groupId, long folderId, int status,
5151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5152                    throws com.liferay.portal.kernel.exception.SystemException {
5153                    return getPersistence()
5154                                       .fetchByG_F_NotST_Last(groupId, folderId, status,
5155                            orderByComparator);
5156            }
5157    
5158            /**
5159            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5160            *
5161            * @param id the primary key of the current journal article
5162            * @param groupId the group ID
5163            * @param folderId the folder ID
5164            * @param status the status
5165            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5166            * @return the previous, current, and next journal article
5167            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5168            * @throws SystemException if a system exception occurred
5169            */
5170            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_NotST_PrevAndNext(
5171                    long id, long groupId, long folderId, int status,
5172                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5173                    throws com.liferay.portal.kernel.exception.SystemException,
5174                            com.liferay.portlet.journal.NoSuchArticleException {
5175                    return getPersistence()
5176                                       .findByG_F_NotST_PrevAndNext(id, groupId, folderId, status,
5177                            orderByComparator);
5178            }
5179    
5180            /**
5181            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5182            *
5183            * @param groupId the group ID
5184            * @param folderId the folder ID
5185            * @param status the status
5186            * @return the matching journal articles that the user has permission to view
5187            * @throws SystemException if a system exception occurred
5188            */
5189            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_NotST(
5190                    long groupId, long folderId, int status)
5191                    throws com.liferay.portal.kernel.exception.SystemException {
5192                    return getPersistence().filterFindByG_F_NotST(groupId, folderId, status);
5193            }
5194    
5195            /**
5196            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5197            *
5198            * <p>
5199            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5200            * </p>
5201            *
5202            * @param groupId the group ID
5203            * @param folderId the folder ID
5204            * @param status the status
5205            * @param start the lower bound of the range of journal articles
5206            * @param end the upper bound of the range of journal articles (not inclusive)
5207            * @return the range of matching journal articles that the user has permission to view
5208            * @throws SystemException if a system exception occurred
5209            */
5210            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_NotST(
5211                    long groupId, long folderId, int status, int start, int end)
5212                    throws com.liferay.portal.kernel.exception.SystemException {
5213                    return getPersistence()
5214                                       .filterFindByG_F_NotST(groupId, folderId, status, start, end);
5215            }
5216    
5217            /**
5218            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5219            *
5220            * <p>
5221            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5222            * </p>
5223            *
5224            * @param groupId the group ID
5225            * @param folderId the folder ID
5226            * @param status the status
5227            * @param start the lower bound of the range of journal articles
5228            * @param end the upper bound of the range of journal articles (not inclusive)
5229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5230            * @return the ordered range of matching journal articles that the user has permission to view
5231            * @throws SystemException if a system exception occurred
5232            */
5233            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_NotST(
5234                    long groupId, long folderId, int status, int start, int end,
5235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5236                    throws com.liferay.portal.kernel.exception.SystemException {
5237                    return getPersistence()
5238                                       .filterFindByG_F_NotST(groupId, folderId, status, start,
5239                            end, orderByComparator);
5240            }
5241    
5242            /**
5243            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5244            *
5245            * @param id the primary key of the current journal article
5246            * @param groupId the group ID
5247            * @param folderId the folder ID
5248            * @param status the status
5249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5250            * @return the previous, current, and next journal article
5251            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5252            * @throws SystemException if a system exception occurred
5253            */
5254            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_NotST_PrevAndNext(
5255                    long id, long groupId, long folderId, int status,
5256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5257                    throws com.liferay.portal.kernel.exception.SystemException,
5258                            com.liferay.portlet.journal.NoSuchArticleException {
5259                    return getPersistence()
5260                                       .filterFindByG_F_NotST_PrevAndNext(id, groupId, folderId,
5261                            status, orderByComparator);
5262            }
5263    
5264            /**
5265            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status &ne; &#63; from the database.
5266            *
5267            * @param groupId the group ID
5268            * @param folderId the folder ID
5269            * @param status the status
5270            * @throws SystemException if a system exception occurred
5271            */
5272            public static void removeByG_F_NotST(long groupId, long folderId, int status)
5273                    throws com.liferay.portal.kernel.exception.SystemException {
5274                    getPersistence().removeByG_F_NotST(groupId, folderId, status);
5275            }
5276    
5277            /**
5278            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5279            *
5280            * @param groupId the group ID
5281            * @param folderId the folder ID
5282            * @param status the status
5283            * @return the number of matching journal articles
5284            * @throws SystemException if a system exception occurred
5285            */
5286            public static int countByG_F_NotST(long groupId, long folderId, int status)
5287                    throws com.liferay.portal.kernel.exception.SystemException {
5288                    return getPersistence().countByG_F_NotST(groupId, folderId, status);
5289            }
5290    
5291            /**
5292            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
5293            *
5294            * @param groupId the group ID
5295            * @param folderId the folder ID
5296            * @param status the status
5297            * @return the number of matching journal articles that the user has permission to view
5298            * @throws SystemException if a system exception occurred
5299            */
5300            public static int filterCountByG_F_NotST(long groupId, long folderId,
5301                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5302                    return getPersistence().filterCountByG_F_NotST(groupId, folderId, status);
5303            }
5304    
5305            /**
5306            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5307            *
5308            * @param groupId the group ID
5309            * @param classNameId the class name ID
5310            * @param classPK the class p k
5311            * @return the matching journal articles
5312            * @throws SystemException if a system exception occurred
5313            */
5314            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5315                    long groupId, long classNameId, long classPK)
5316                    throws com.liferay.portal.kernel.exception.SystemException {
5317                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5318            }
5319    
5320            /**
5321            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5322            *
5323            * <p>
5324            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5325            * </p>
5326            *
5327            * @param groupId the group ID
5328            * @param classNameId the class name ID
5329            * @param classPK the class p k
5330            * @param start the lower bound of the range of journal articles
5331            * @param end the upper bound of the range of journal articles (not inclusive)
5332            * @return the range of matching journal articles
5333            * @throws SystemException if a system exception occurred
5334            */
5335            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5336                    long groupId, long classNameId, long classPK, int start, int end)
5337                    throws com.liferay.portal.kernel.exception.SystemException {
5338                    return getPersistence()
5339                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5340            }
5341    
5342            /**
5343            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5344            *
5345            * <p>
5346            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5347            * </p>
5348            *
5349            * @param groupId the group ID
5350            * @param classNameId the class name ID
5351            * @param classPK the class p k
5352            * @param start the lower bound of the range of journal articles
5353            * @param end the upper bound of the range of journal articles (not inclusive)
5354            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5355            * @return the ordered range of matching journal articles
5356            * @throws SystemException if a system exception occurred
5357            */
5358            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5359                    long groupId, long classNameId, long classPK, int start, int end,
5360                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5361                    throws com.liferay.portal.kernel.exception.SystemException {
5362                    return getPersistence()
5363                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
5364                            orderByComparator);
5365            }
5366    
5367            /**
5368            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5369            *
5370            * @param groupId the group ID
5371            * @param classNameId the class name ID
5372            * @param classPK the class p k
5373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5374            * @return the first matching journal article
5375            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5376            * @throws SystemException if a system exception occurred
5377            */
5378            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
5379                    long groupId, long classNameId, long classPK,
5380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5381                    throws com.liferay.portal.kernel.exception.SystemException,
5382                            com.liferay.portlet.journal.NoSuchArticleException {
5383                    return getPersistence()
5384                                       .findByG_C_C_First(groupId, classNameId, classPK,
5385                            orderByComparator);
5386            }
5387    
5388            /**
5389            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5390            *
5391            * @param groupId the group ID
5392            * @param classNameId the class name ID
5393            * @param classPK the class p k
5394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5395            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5396            * @throws SystemException if a system exception occurred
5397            */
5398            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
5399                    long groupId, long classNameId, long classPK,
5400                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5401                    throws com.liferay.portal.kernel.exception.SystemException {
5402                    return getPersistence()
5403                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5404                            orderByComparator);
5405            }
5406    
5407            /**
5408            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5409            *
5410            * @param groupId the group ID
5411            * @param classNameId the class name ID
5412            * @param classPK the class p k
5413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5414            * @return the last matching journal article
5415            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5416            * @throws SystemException if a system exception occurred
5417            */
5418            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
5419                    long groupId, long classNameId, long classPK,
5420                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5421                    throws com.liferay.portal.kernel.exception.SystemException,
5422                            com.liferay.portlet.journal.NoSuchArticleException {
5423                    return getPersistence()
5424                                       .findByG_C_C_Last(groupId, classNameId, classPK,
5425                            orderByComparator);
5426            }
5427    
5428            /**
5429            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5430            *
5431            * @param groupId the group ID
5432            * @param classNameId the class name ID
5433            * @param classPK the class p k
5434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5435            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5436            * @throws SystemException if a system exception occurred
5437            */
5438            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
5439                    long groupId, long classNameId, long classPK,
5440                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5441                    throws com.liferay.portal.kernel.exception.SystemException {
5442                    return getPersistence()
5443                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
5444                            orderByComparator);
5445            }
5446    
5447            /**
5448            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5449            *
5450            * @param id the primary key of the current journal article
5451            * @param groupId the group ID
5452            * @param classNameId the class name ID
5453            * @param classPK the class p k
5454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5455            * @return the previous, current, and next journal article
5456            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5457            * @throws SystemException if a system exception occurred
5458            */
5459            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
5460                    long id, long groupId, long classNameId, long classPK,
5461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5462                    throws com.liferay.portal.kernel.exception.SystemException,
5463                            com.liferay.portlet.journal.NoSuchArticleException {
5464                    return getPersistence()
5465                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5466                            orderByComparator);
5467            }
5468    
5469            /**
5470            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5471            *
5472            * @param groupId the group ID
5473            * @param classNameId the class name ID
5474            * @param classPK the class p k
5475            * @return the matching journal articles that the user has permission to view
5476            * @throws SystemException if a system exception occurred
5477            */
5478            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5479                    long groupId, long classNameId, long classPK)
5480                    throws com.liferay.portal.kernel.exception.SystemException {
5481                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5482            }
5483    
5484            /**
5485            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5486            *
5487            * <p>
5488            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5489            * </p>
5490            *
5491            * @param groupId the group ID
5492            * @param classNameId the class name ID
5493            * @param classPK the class p k
5494            * @param start the lower bound of the range of journal articles
5495            * @param end the upper bound of the range of journal articles (not inclusive)
5496            * @return the range of matching journal articles that the user has permission to view
5497            * @throws SystemException if a system exception occurred
5498            */
5499            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5500                    long groupId, long classNameId, long classPK, int start, int end)
5501                    throws com.liferay.portal.kernel.exception.SystemException {
5502                    return getPersistence()
5503                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
5504            }
5505    
5506            /**
5507            * 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;.
5508            *
5509            * <p>
5510            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5511            * </p>
5512            *
5513            * @param groupId the group ID
5514            * @param classNameId the class name ID
5515            * @param classPK the class p k
5516            * @param start the lower bound of the range of journal articles
5517            * @param end the upper bound of the range of journal articles (not inclusive)
5518            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5519            * @return the ordered range of matching journal articles that the user has permission to view
5520            * @throws SystemException if a system exception occurred
5521            */
5522            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5523                    long groupId, long classNameId, long classPK, int start, int end,
5524                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5525                    throws com.liferay.portal.kernel.exception.SystemException {
5526                    return getPersistence()
5527                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
5528                            end, orderByComparator);
5529            }
5530    
5531            /**
5532            * 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;.
5533            *
5534            * @param id the primary key of the current journal article
5535            * @param groupId the group ID
5536            * @param classNameId the class name ID
5537            * @param classPK the class p k
5538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5539            * @return the previous, current, and next journal article
5540            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5541            * @throws SystemException if a system exception occurred
5542            */
5543            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
5544                    long id, long groupId, long classNameId, long classPK,
5545                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5546                    throws com.liferay.portal.kernel.exception.SystemException,
5547                            com.liferay.portlet.journal.NoSuchArticleException {
5548                    return getPersistence()
5549                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
5550                            classPK, orderByComparator);
5551            }
5552    
5553            /**
5554            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5555            *
5556            * @param groupId the group ID
5557            * @param classNameId the class name ID
5558            * @param classPK the class p k
5559            * @throws SystemException if a system exception occurred
5560            */
5561            public static void removeByG_C_C(long groupId, long classNameId,
5562                    long classPK)
5563                    throws com.liferay.portal.kernel.exception.SystemException {
5564                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5565            }
5566    
5567            /**
5568            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5569            *
5570            * @param groupId the group ID
5571            * @param classNameId the class name ID
5572            * @param classPK the class p k
5573            * @return the number of matching journal articles
5574            * @throws SystemException if a system exception occurred
5575            */
5576            public static int countByG_C_C(long groupId, long classNameId, long classPK)
5577                    throws com.liferay.portal.kernel.exception.SystemException {
5578                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5579            }
5580    
5581            /**
5582            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5583            *
5584            * @param groupId the group ID
5585            * @param classNameId the class name ID
5586            * @param classPK the class p k
5587            * @return the number of matching journal articles that the user has permission to view
5588            * @throws SystemException if a system exception occurred
5589            */
5590            public static int filterCountByG_C_C(long groupId, long classNameId,
5591                    long classPK)
5592                    throws com.liferay.portal.kernel.exception.SystemException {
5593                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5594            }
5595    
5596            /**
5597            * 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.
5598            *
5599            * @param groupId the group ID
5600            * @param classNameId the class name ID
5601            * @param structureId the structure ID
5602            * @return the matching journal article
5603            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5604            * @throws SystemException if a system exception occurred
5605            */
5606            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
5607                    long groupId, long classNameId, java.lang.String structureId)
5608                    throws com.liferay.portal.kernel.exception.SystemException,
5609                            com.liferay.portlet.journal.NoSuchArticleException {
5610                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
5611            }
5612    
5613            /**
5614            * 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.
5615            *
5616            * @param groupId the group ID
5617            * @param classNameId the class name ID
5618            * @param structureId the structure ID
5619            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5620            * @throws SystemException if a system exception occurred
5621            */
5622            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5623                    long groupId, long classNameId, java.lang.String structureId)
5624                    throws com.liferay.portal.kernel.exception.SystemException {
5625                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
5626            }
5627    
5628            /**
5629            * 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.
5630            *
5631            * @param groupId the group ID
5632            * @param classNameId the class name ID
5633            * @param structureId the structure ID
5634            * @param retrieveFromCache whether to use the finder cache
5635            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5636            * @throws SystemException if a system exception occurred
5637            */
5638            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5639                    long groupId, long classNameId, java.lang.String structureId,
5640                    boolean retrieveFromCache)
5641                    throws com.liferay.portal.kernel.exception.SystemException {
5642                    return getPersistence()
5643                                       .fetchByG_C_S(groupId, classNameId, structureId,
5644                            retrieveFromCache);
5645            }
5646    
5647            /**
5648            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
5649            *
5650            * @param groupId the group ID
5651            * @param classNameId the class name ID
5652            * @param structureId the structure ID
5653            * @return the journal article that was removed
5654            * @throws SystemException if a system exception occurred
5655            */
5656            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
5657                    long groupId, long classNameId, java.lang.String structureId)
5658                    throws com.liferay.portal.kernel.exception.SystemException,
5659                            com.liferay.portlet.journal.NoSuchArticleException {
5660                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
5661            }
5662    
5663            /**
5664            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
5665            *
5666            * @param groupId the group ID
5667            * @param classNameId the class name ID
5668            * @param structureId the structure ID
5669            * @return the number of matching journal articles
5670            * @throws SystemException if a system exception occurred
5671            */
5672            public static int countByG_C_S(long groupId, long classNameId,
5673                    java.lang.String structureId)
5674                    throws com.liferay.portal.kernel.exception.SystemException {
5675                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
5676            }
5677    
5678            /**
5679            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5680            *
5681            * @param groupId the group ID
5682            * @param classNameId the class name ID
5683            * @param templateId the template ID
5684            * @return the matching journal articles
5685            * @throws SystemException if a system exception occurred
5686            */
5687            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5688                    long groupId, long classNameId, java.lang.String templateId)
5689                    throws com.liferay.portal.kernel.exception.SystemException {
5690                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
5691            }
5692    
5693            /**
5694            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5695            *
5696            * <p>
5697            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5698            * </p>
5699            *
5700            * @param groupId the group ID
5701            * @param classNameId the class name ID
5702            * @param templateId the template ID
5703            * @param start the lower bound of the range of journal articles
5704            * @param end the upper bound of the range of journal articles (not inclusive)
5705            * @return the range of matching journal articles
5706            * @throws SystemException if a system exception occurred
5707            */
5708            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5709                    long groupId, long classNameId, java.lang.String templateId, int start,
5710                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5711                    return getPersistence()
5712                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
5713            }
5714    
5715            /**
5716            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5717            *
5718            * <p>
5719            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5720            * </p>
5721            *
5722            * @param groupId the group ID
5723            * @param classNameId the class name ID
5724            * @param templateId the template ID
5725            * @param start the lower bound of the range of journal articles
5726            * @param end the upper bound of the range of journal articles (not inclusive)
5727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5728            * @return the ordered range of matching journal articles
5729            * @throws SystemException if a system exception occurred
5730            */
5731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5732                    long groupId, long classNameId, java.lang.String templateId, int start,
5733                    int end,
5734                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5735                    throws com.liferay.portal.kernel.exception.SystemException {
5736                    return getPersistence()
5737                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
5738                            orderByComparator);
5739            }
5740    
5741            /**
5742            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5743            *
5744            * @param groupId the group ID
5745            * @param classNameId the class name ID
5746            * @param templateId the template ID
5747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5748            * @return the first matching journal article
5749            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5750            * @throws SystemException if a system exception occurred
5751            */
5752            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
5753                    long groupId, long classNameId, java.lang.String templateId,
5754                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5755                    throws com.liferay.portal.kernel.exception.SystemException,
5756                            com.liferay.portlet.journal.NoSuchArticleException {
5757                    return getPersistence()
5758                                       .findByG_C_T_First(groupId, classNameId, templateId,
5759                            orderByComparator);
5760            }
5761    
5762            /**
5763            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5764            *
5765            * @param groupId the group ID
5766            * @param classNameId the class name ID
5767            * @param templateId the template ID
5768            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5769            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5770            * @throws SystemException if a system exception occurred
5771            */
5772            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
5773                    long groupId, long classNameId, java.lang.String templateId,
5774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5775                    throws com.liferay.portal.kernel.exception.SystemException {
5776                    return getPersistence()
5777                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
5778                            orderByComparator);
5779            }
5780    
5781            /**
5782            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5783            *
5784            * @param groupId the group ID
5785            * @param classNameId the class name ID
5786            * @param templateId the template ID
5787            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5788            * @return the last matching journal article
5789            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5790            * @throws SystemException if a system exception occurred
5791            */
5792            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
5793                    long groupId, long classNameId, java.lang.String templateId,
5794                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5795                    throws com.liferay.portal.kernel.exception.SystemException,
5796                            com.liferay.portlet.journal.NoSuchArticleException {
5797                    return getPersistence()
5798                                       .findByG_C_T_Last(groupId, classNameId, templateId,
5799                            orderByComparator);
5800            }
5801    
5802            /**
5803            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5804            *
5805            * @param groupId the group ID
5806            * @param classNameId the class name ID
5807            * @param templateId the template ID
5808            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5809            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5810            * @throws SystemException if a system exception occurred
5811            */
5812            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
5813                    long groupId, long classNameId, java.lang.String templateId,
5814                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5815                    throws com.liferay.portal.kernel.exception.SystemException {
5816                    return getPersistence()
5817                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
5818                            orderByComparator);
5819            }
5820    
5821            /**
5822            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5823            *
5824            * @param id the primary key of the current journal article
5825            * @param groupId the group ID
5826            * @param classNameId the class name ID
5827            * @param templateId the template ID
5828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5829            * @return the previous, current, and next journal article
5830            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5831            * @throws SystemException if a system exception occurred
5832            */
5833            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
5834                    long id, long groupId, long classNameId, java.lang.String templateId,
5835                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5836                    throws com.liferay.portal.kernel.exception.SystemException,
5837                            com.liferay.portlet.journal.NoSuchArticleException {
5838                    return getPersistence()
5839                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
5840                            templateId, orderByComparator);
5841            }
5842    
5843            /**
5844            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5845            *
5846            * @param groupId the group ID
5847            * @param classNameId the class name ID
5848            * @param templateId the template ID
5849            * @return the matching journal articles that the user has permission to view
5850            * @throws SystemException if a system exception occurred
5851            */
5852            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5853                    long groupId, long classNameId, java.lang.String templateId)
5854                    throws com.liferay.portal.kernel.exception.SystemException {
5855                    return getPersistence()
5856                                       .filterFindByG_C_T(groupId, classNameId, templateId);
5857            }
5858    
5859            /**
5860            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5861            *
5862            * <p>
5863            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5864            * </p>
5865            *
5866            * @param groupId the group ID
5867            * @param classNameId the class name ID
5868            * @param templateId the template ID
5869            * @param start the lower bound of the range of journal articles
5870            * @param end the upper bound of the range of journal articles (not inclusive)
5871            * @return the range of matching journal articles that the user has permission to view
5872            * @throws SystemException if a system exception occurred
5873            */
5874            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5875                    long groupId, long classNameId, java.lang.String templateId, int start,
5876                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5877                    return getPersistence()
5878                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
5879                            end);
5880            }
5881    
5882            /**
5883            * 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;.
5884            *
5885            * <p>
5886            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5887            * </p>
5888            *
5889            * @param groupId the group ID
5890            * @param classNameId the class name ID
5891            * @param templateId the template ID
5892            * @param start the lower bound of the range of journal articles
5893            * @param end the upper bound of the range of journal articles (not inclusive)
5894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5895            * @return the ordered range of matching journal articles that the user has permission to view
5896            * @throws SystemException if a system exception occurred
5897            */
5898            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5899                    long groupId, long classNameId, java.lang.String templateId, int start,
5900                    int end,
5901                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5902                    throws com.liferay.portal.kernel.exception.SystemException {
5903                    return getPersistence()
5904                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
5905                            end, orderByComparator);
5906            }
5907    
5908            /**
5909            * 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;.
5910            *
5911            * @param id the primary key of the current journal article
5912            * @param groupId the group ID
5913            * @param classNameId the class name ID
5914            * @param templateId the template ID
5915            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5916            * @return the previous, current, and next journal article
5917            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5918            * @throws SystemException if a system exception occurred
5919            */
5920            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
5921                    long id, long groupId, long classNameId, java.lang.String templateId,
5922                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5923                    throws com.liferay.portal.kernel.exception.SystemException,
5924                            com.liferay.portlet.journal.NoSuchArticleException {
5925                    return getPersistence()
5926                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
5927                            templateId, orderByComparator);
5928            }
5929    
5930            /**
5931            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
5932            *
5933            * @param groupId the group ID
5934            * @param classNameId the class name ID
5935            * @param templateId the template ID
5936            * @throws SystemException if a system exception occurred
5937            */
5938            public static void removeByG_C_T(long groupId, long classNameId,
5939                    java.lang.String templateId)
5940                    throws com.liferay.portal.kernel.exception.SystemException {
5941                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
5942            }
5943    
5944            /**
5945            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5946            *
5947            * @param groupId the group ID
5948            * @param classNameId the class name ID
5949            * @param templateId the template ID
5950            * @return the number of matching journal articles
5951            * @throws SystemException if a system exception occurred
5952            */
5953            public static int countByG_C_T(long groupId, long classNameId,
5954                    java.lang.String templateId)
5955                    throws com.liferay.portal.kernel.exception.SystemException {
5956                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
5957            }
5958    
5959            /**
5960            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5961            *
5962            * @param groupId the group ID
5963            * @param classNameId the class name ID
5964            * @param templateId the template ID
5965            * @return the number of matching journal articles that the user has permission to view
5966            * @throws SystemException if a system exception occurred
5967            */
5968            public static int filterCountByG_C_T(long groupId, long classNameId,
5969                    java.lang.String templateId)
5970                    throws com.liferay.portal.kernel.exception.SystemException {
5971                    return getPersistence()
5972                                       .filterCountByG_C_T(groupId, classNameId, templateId);
5973            }
5974    
5975            /**
5976            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5977            *
5978            * @param groupId the group ID
5979            * @param classNameId the class name ID
5980            * @param layoutUuid the layout uuid
5981            * @return the matching journal articles
5982            * @throws SystemException if a system exception occurred
5983            */
5984            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5985                    long groupId, long classNameId, java.lang.String layoutUuid)
5986                    throws com.liferay.portal.kernel.exception.SystemException {
5987                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
5988            }
5989    
5990            /**
5991            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5992            *
5993            * <p>
5994            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5995            * </p>
5996            *
5997            * @param groupId the group ID
5998            * @param classNameId the class name ID
5999            * @param layoutUuid the layout uuid
6000            * @param start the lower bound of the range of journal articles
6001            * @param end the upper bound of the range of journal articles (not inclusive)
6002            * @return the range of matching journal articles
6003            * @throws SystemException if a system exception occurred
6004            */
6005            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6006                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6007                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6008                    return getPersistence()
6009                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6010            }
6011    
6012            /**
6013            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6014            *
6015            * <p>
6016            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6017            * </p>
6018            *
6019            * @param groupId the group ID
6020            * @param classNameId the class name ID
6021            * @param layoutUuid the layout uuid
6022            * @param start the lower bound of the range of journal articles
6023            * @param end the upper bound of the range of journal articles (not inclusive)
6024            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6025            * @return the ordered range of matching journal articles
6026            * @throws SystemException if a system exception occurred
6027            */
6028            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6029                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6030                    int end,
6031                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6032                    throws com.liferay.portal.kernel.exception.SystemException {
6033                    return getPersistence()
6034                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6035                            orderByComparator);
6036            }
6037    
6038            /**
6039            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6040            *
6041            * @param groupId the group ID
6042            * @param classNameId the class name ID
6043            * @param layoutUuid the layout uuid
6044            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6045            * @return the first matching journal article
6046            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6047            * @throws SystemException if a system exception occurred
6048            */
6049            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
6050                    long groupId, long classNameId, java.lang.String layoutUuid,
6051                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6052                    throws com.liferay.portal.kernel.exception.SystemException,
6053                            com.liferay.portlet.journal.NoSuchArticleException {
6054                    return getPersistence()
6055                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
6056                            orderByComparator);
6057            }
6058    
6059            /**
6060            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6061            *
6062            * @param groupId the group ID
6063            * @param classNameId the class name ID
6064            * @param layoutUuid the layout uuid
6065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6066            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6067            * @throws SystemException if a system exception occurred
6068            */
6069            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
6070                    long groupId, long classNameId, java.lang.String layoutUuid,
6071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6072                    throws com.liferay.portal.kernel.exception.SystemException {
6073                    return getPersistence()
6074                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
6075                            orderByComparator);
6076            }
6077    
6078            /**
6079            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6080            *
6081            * @param groupId the group ID
6082            * @param classNameId the class name ID
6083            * @param layoutUuid the layout uuid
6084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6085            * @return the last matching journal article
6086            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6087            * @throws SystemException if a system exception occurred
6088            */
6089            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
6090                    long groupId, long classNameId, java.lang.String layoutUuid,
6091                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6092                    throws com.liferay.portal.kernel.exception.SystemException,
6093                            com.liferay.portlet.journal.NoSuchArticleException {
6094                    return getPersistence()
6095                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
6096                            orderByComparator);
6097            }
6098    
6099            /**
6100            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6101            *
6102            * @param groupId the group ID
6103            * @param classNameId the class name ID
6104            * @param layoutUuid the layout uuid
6105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6106            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6107            * @throws SystemException if a system exception occurred
6108            */
6109            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
6110                    long groupId, long classNameId, java.lang.String layoutUuid,
6111                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6112                    throws com.liferay.portal.kernel.exception.SystemException {
6113                    return getPersistence()
6114                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
6115                            orderByComparator);
6116            }
6117    
6118            /**
6119            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6120            *
6121            * @param id the primary key of the current journal article
6122            * @param groupId the group ID
6123            * @param classNameId the class name ID
6124            * @param layoutUuid the layout uuid
6125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6126            * @return the previous, current, and next journal article
6127            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6128            * @throws SystemException if a system exception occurred
6129            */
6130            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
6131                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6133                    throws com.liferay.portal.kernel.exception.SystemException,
6134                            com.liferay.portlet.journal.NoSuchArticleException {
6135                    return getPersistence()
6136                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
6137                            layoutUuid, orderByComparator);
6138            }
6139    
6140            /**
6141            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6142            *
6143            * @param groupId the group ID
6144            * @param classNameId the class name ID
6145            * @param layoutUuid the layout uuid
6146            * @return the matching journal articles that the user has permission to view
6147            * @throws SystemException if a system exception occurred
6148            */
6149            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6150                    long groupId, long classNameId, java.lang.String layoutUuid)
6151                    throws com.liferay.portal.kernel.exception.SystemException {
6152                    return getPersistence()
6153                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
6154            }
6155    
6156            /**
6157            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6158            *
6159            * <p>
6160            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6161            * </p>
6162            *
6163            * @param groupId the group ID
6164            * @param classNameId the class name ID
6165            * @param layoutUuid the layout uuid
6166            * @param start the lower bound of the range of journal articles
6167            * @param end the upper bound of the range of journal articles (not inclusive)
6168            * @return the range of matching journal articles that the user has permission to view
6169            * @throws SystemException if a system exception occurred
6170            */
6171            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6172                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6173                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6174                    return getPersistence()
6175                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6176                            end);
6177            }
6178    
6179            /**
6180            * 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;.
6181            *
6182            * <p>
6183            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6184            * </p>
6185            *
6186            * @param groupId the group ID
6187            * @param classNameId the class name ID
6188            * @param layoutUuid the layout uuid
6189            * @param start the lower bound of the range of journal articles
6190            * @param end the upper bound of the range of journal articles (not inclusive)
6191            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6192            * @return the ordered range of matching journal articles that the user has permission to view
6193            * @throws SystemException if a system exception occurred
6194            */
6195            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6196                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6197                    int end,
6198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6199                    throws com.liferay.portal.kernel.exception.SystemException {
6200                    return getPersistence()
6201                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6202                            end, orderByComparator);
6203            }
6204    
6205            /**
6206            * 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;.
6207            *
6208            * @param id the primary key of the current journal article
6209            * @param groupId the group ID
6210            * @param classNameId the class name ID
6211            * @param layoutUuid the layout uuid
6212            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6213            * @return the previous, current, and next journal article
6214            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6215            * @throws SystemException if a system exception occurred
6216            */
6217            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
6218                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6219                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6220                    throws com.liferay.portal.kernel.exception.SystemException,
6221                            com.liferay.portlet.journal.NoSuchArticleException {
6222                    return getPersistence()
6223                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6224                            layoutUuid, orderByComparator);
6225            }
6226    
6227            /**
6228            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6229            *
6230            * @param groupId the group ID
6231            * @param classNameId the class name ID
6232            * @param layoutUuid the layout uuid
6233            * @throws SystemException if a system exception occurred
6234            */
6235            public static void removeByG_C_L(long groupId, long classNameId,
6236                    java.lang.String layoutUuid)
6237                    throws com.liferay.portal.kernel.exception.SystemException {
6238                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6239            }
6240    
6241            /**
6242            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6243            *
6244            * @param groupId the group ID
6245            * @param classNameId the class name ID
6246            * @param layoutUuid the layout uuid
6247            * @return the number of matching journal articles
6248            * @throws SystemException if a system exception occurred
6249            */
6250            public static int countByG_C_L(long groupId, long classNameId,
6251                    java.lang.String layoutUuid)
6252                    throws com.liferay.portal.kernel.exception.SystemException {
6253                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6254            }
6255    
6256            /**
6257            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6258            *
6259            * @param groupId the group ID
6260            * @param classNameId the class name ID
6261            * @param layoutUuid the layout uuid
6262            * @return the number of matching journal articles that the user has permission to view
6263            * @throws SystemException if a system exception occurred
6264            */
6265            public static int filterCountByG_C_L(long groupId, long classNameId,
6266                    java.lang.String layoutUuid)
6267                    throws com.liferay.portal.kernel.exception.SystemException {
6268                    return getPersistence()
6269                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
6270            }
6271    
6272            /**
6273            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6274            *
6275            * @param groupId the group ID
6276            * @param userId the user ID
6277            * @param classNameId the class name ID
6278            * @return the matching journal articles
6279            * @throws SystemException if a system exception occurred
6280            */
6281            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6282                    long groupId, long userId, long classNameId)
6283                    throws com.liferay.portal.kernel.exception.SystemException {
6284                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
6285            }
6286    
6287            /**
6288            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6289            *
6290            * <p>
6291            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6292            * </p>
6293            *
6294            * @param groupId the group ID
6295            * @param userId the user ID
6296            * @param classNameId the class name ID
6297            * @param start the lower bound of the range of journal articles
6298            * @param end the upper bound of the range of journal articles (not inclusive)
6299            * @return the range of matching journal articles
6300            * @throws SystemException if a system exception occurred
6301            */
6302            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6303                    long groupId, long userId, long classNameId, int start, int end)
6304                    throws com.liferay.portal.kernel.exception.SystemException {
6305                    return getPersistence()
6306                                       .findByG_U_C(groupId, userId, classNameId, start, end);
6307            }
6308    
6309            /**
6310            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6311            *
6312            * <p>
6313            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6314            * </p>
6315            *
6316            * @param groupId the group ID
6317            * @param userId the user ID
6318            * @param classNameId the class name ID
6319            * @param start the lower bound of the range of journal articles
6320            * @param end the upper bound of the range of journal articles (not inclusive)
6321            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6322            * @return the ordered range of matching journal articles
6323            * @throws SystemException if a system exception occurred
6324            */
6325            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6326                    long groupId, long userId, long classNameId, int start, int end,
6327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6328                    throws com.liferay.portal.kernel.exception.SystemException {
6329                    return getPersistence()
6330                                       .findByG_U_C(groupId, userId, classNameId, start, end,
6331                            orderByComparator);
6332            }
6333    
6334            /**
6335            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6336            *
6337            * @param groupId the group ID
6338            * @param userId the user ID
6339            * @param classNameId the class name ID
6340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6341            * @return the first matching journal article
6342            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6343            * @throws SystemException if a system exception occurred
6344            */
6345            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
6346                    long groupId, long userId, long classNameId,
6347                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6348                    throws com.liferay.portal.kernel.exception.SystemException,
6349                            com.liferay.portlet.journal.NoSuchArticleException {
6350                    return getPersistence()
6351                                       .findByG_U_C_First(groupId, userId, classNameId,
6352                            orderByComparator);
6353            }
6354    
6355            /**
6356            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6357            *
6358            * @param groupId the group ID
6359            * @param userId the user ID
6360            * @param classNameId the class name ID
6361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6362            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6363            * @throws SystemException if a system exception occurred
6364            */
6365            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
6366                    long groupId, long userId, long classNameId,
6367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6368                    throws com.liferay.portal.kernel.exception.SystemException {
6369                    return getPersistence()
6370                                       .fetchByG_U_C_First(groupId, userId, classNameId,
6371                            orderByComparator);
6372            }
6373    
6374            /**
6375            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6376            *
6377            * @param groupId the group ID
6378            * @param userId the user ID
6379            * @param classNameId the class name ID
6380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6381            * @return the last matching journal article
6382            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6383            * @throws SystemException if a system exception occurred
6384            */
6385            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
6386                    long groupId, long userId, long classNameId,
6387                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6388                    throws com.liferay.portal.kernel.exception.SystemException,
6389                            com.liferay.portlet.journal.NoSuchArticleException {
6390                    return getPersistence()
6391                                       .findByG_U_C_Last(groupId, userId, classNameId,
6392                            orderByComparator);
6393            }
6394    
6395            /**
6396            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6397            *
6398            * @param groupId the group ID
6399            * @param userId the user ID
6400            * @param classNameId the class name ID
6401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6402            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6403            * @throws SystemException if a system exception occurred
6404            */
6405            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
6406                    long groupId, long userId, long classNameId,
6407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6408                    throws com.liferay.portal.kernel.exception.SystemException {
6409                    return getPersistence()
6410                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
6411                            orderByComparator);
6412            }
6413    
6414            /**
6415            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6416            *
6417            * @param id the primary key of the current journal article
6418            * @param groupId the group ID
6419            * @param userId the user ID
6420            * @param classNameId the class name ID
6421            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6422            * @return the previous, current, and next journal article
6423            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6424            * @throws SystemException if a system exception occurred
6425            */
6426            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
6427                    long id, long groupId, long userId, long classNameId,
6428                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6429                    throws com.liferay.portal.kernel.exception.SystemException,
6430                            com.liferay.portlet.journal.NoSuchArticleException {
6431                    return getPersistence()
6432                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
6433                            orderByComparator);
6434            }
6435    
6436            /**
6437            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6438            *
6439            * @param groupId the group ID
6440            * @param userId the user ID
6441            * @param classNameId the class name ID
6442            * @return the matching journal articles that the user has permission to view
6443            * @throws SystemException if a system exception occurred
6444            */
6445            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6446                    long groupId, long userId, long classNameId)
6447                    throws com.liferay.portal.kernel.exception.SystemException {
6448                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
6449            }
6450    
6451            /**
6452            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6453            *
6454            * <p>
6455            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6456            * </p>
6457            *
6458            * @param groupId the group ID
6459            * @param userId the user ID
6460            * @param classNameId the class name ID
6461            * @param start the lower bound of the range of journal articles
6462            * @param end the upper bound of the range of journal articles (not inclusive)
6463            * @return the range of matching journal articles that the user has permission to view
6464            * @throws SystemException if a system exception occurred
6465            */
6466            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6467                    long groupId, long userId, long classNameId, int start, int end)
6468                    throws com.liferay.portal.kernel.exception.SystemException {
6469                    return getPersistence()
6470                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
6471            }
6472    
6473            /**
6474            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6475            *
6476            * <p>
6477            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6478            * </p>
6479            *
6480            * @param groupId the group ID
6481            * @param userId the user ID
6482            * @param classNameId the class name ID
6483            * @param start the lower bound of the range of journal articles
6484            * @param end the upper bound of the range of journal articles (not inclusive)
6485            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6486            * @return the ordered range of matching journal articles that the user has permission to view
6487            * @throws SystemException if a system exception occurred
6488            */
6489            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6490                    long groupId, long userId, long classNameId, int start, int end,
6491                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6492                    throws com.liferay.portal.kernel.exception.SystemException {
6493                    return getPersistence()
6494                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
6495                            orderByComparator);
6496            }
6497    
6498            /**
6499            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6500            *
6501            * @param id the primary key of the current journal article
6502            * @param groupId the group ID
6503            * @param userId the user ID
6504            * @param classNameId the class name ID
6505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6506            * @return the previous, current, and next journal article
6507            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6508            * @throws SystemException if a system exception occurred
6509            */
6510            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
6511                    long id, long groupId, long userId, long classNameId,
6512                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6513                    throws com.liferay.portal.kernel.exception.SystemException,
6514                            com.liferay.portlet.journal.NoSuchArticleException {
6515                    return getPersistence()
6516                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
6517                            classNameId, orderByComparator);
6518            }
6519    
6520            /**
6521            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
6522            *
6523            * @param groupId the group ID
6524            * @param userId the user ID
6525            * @param classNameId the class name ID
6526            * @throws SystemException if a system exception occurred
6527            */
6528            public static void removeByG_U_C(long groupId, long userId, long classNameId)
6529                    throws com.liferay.portal.kernel.exception.SystemException {
6530                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
6531            }
6532    
6533            /**
6534            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6535            *
6536            * @param groupId the group ID
6537            * @param userId the user ID
6538            * @param classNameId the class name ID
6539            * @return the number of matching journal articles
6540            * @throws SystemException if a system exception occurred
6541            */
6542            public static int countByG_U_C(long groupId, long userId, long classNameId)
6543                    throws com.liferay.portal.kernel.exception.SystemException {
6544                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
6545            }
6546    
6547            /**
6548            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6549            *
6550            * @param groupId the group ID
6551            * @param userId the user ID
6552            * @param classNameId the class name ID
6553            * @return the number of matching journal articles that the user has permission to view
6554            * @throws SystemException if a system exception occurred
6555            */
6556            public static int filterCountByG_U_C(long groupId, long userId,
6557                    long classNameId)
6558                    throws com.liferay.portal.kernel.exception.SystemException {
6559                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
6560            }
6561    
6562            /**
6563            * 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.
6564            *
6565            * @param groupId the group ID
6566            * @param articleId the article ID
6567            * @param version the version
6568            * @return the matching journal article
6569            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6570            * @throws SystemException if a system exception occurred
6571            */
6572            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
6573                    long groupId, java.lang.String articleId, double version)
6574                    throws com.liferay.portal.kernel.exception.SystemException,
6575                            com.liferay.portlet.journal.NoSuchArticleException {
6576                    return getPersistence().findByG_A_V(groupId, articleId, version);
6577            }
6578    
6579            /**
6580            * 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.
6581            *
6582            * @param groupId the group ID
6583            * @param articleId the article ID
6584            * @param version the version
6585            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6586            * @throws SystemException if a system exception occurred
6587            */
6588            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6589                    long groupId, java.lang.String articleId, double version)
6590                    throws com.liferay.portal.kernel.exception.SystemException {
6591                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
6592            }
6593    
6594            /**
6595            * 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.
6596            *
6597            * @param groupId the group ID
6598            * @param articleId the article ID
6599            * @param version the version
6600            * @param retrieveFromCache whether to use the finder cache
6601            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6602            * @throws SystemException if a system exception occurred
6603            */
6604            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6605                    long groupId, java.lang.String articleId, double version,
6606                    boolean retrieveFromCache)
6607                    throws com.liferay.portal.kernel.exception.SystemException {
6608                    return getPersistence()
6609                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
6610            }
6611    
6612            /**
6613            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
6614            *
6615            * @param groupId the group ID
6616            * @param articleId the article ID
6617            * @param version the version
6618            * @return the journal article that was removed
6619            * @throws SystemException if a system exception occurred
6620            */
6621            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
6622                    long groupId, java.lang.String articleId, double version)
6623                    throws com.liferay.portal.kernel.exception.SystemException,
6624                            com.liferay.portlet.journal.NoSuchArticleException {
6625                    return getPersistence().removeByG_A_V(groupId, articleId, version);
6626            }
6627    
6628            /**
6629            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
6630            *
6631            * @param groupId the group ID
6632            * @param articleId the article ID
6633            * @param version the version
6634            * @return the number of matching journal articles
6635            * @throws SystemException if a system exception occurred
6636            */
6637            public static int countByG_A_V(long groupId, java.lang.String articleId,
6638                    double version)
6639                    throws com.liferay.portal.kernel.exception.SystemException {
6640                    return getPersistence().countByG_A_V(groupId, articleId, version);
6641            }
6642    
6643            /**
6644            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6645            *
6646            * @param groupId the group ID
6647            * @param articleId the article ID
6648            * @param status the status
6649            * @return the matching journal articles
6650            * @throws SystemException if a system exception occurred
6651            */
6652            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6653                    long groupId, java.lang.String articleId, int status)
6654                    throws com.liferay.portal.kernel.exception.SystemException {
6655                    return getPersistence().findByG_A_ST(groupId, articleId, status);
6656            }
6657    
6658            /**
6659            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6660            *
6661            * <p>
6662            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6663            * </p>
6664            *
6665            * @param groupId the group ID
6666            * @param articleId the article ID
6667            * @param status the status
6668            * @param start the lower bound of the range of journal articles
6669            * @param end the upper bound of the range of journal articles (not inclusive)
6670            * @return the range of matching journal articles
6671            * @throws SystemException if a system exception occurred
6672            */
6673            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6674                    long groupId, java.lang.String articleId, int status, int start, int end)
6675                    throws com.liferay.portal.kernel.exception.SystemException {
6676                    return getPersistence()
6677                                       .findByG_A_ST(groupId, articleId, status, start, end);
6678            }
6679    
6680            /**
6681            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6682            *
6683            * <p>
6684            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6685            * </p>
6686            *
6687            * @param groupId the group ID
6688            * @param articleId the article ID
6689            * @param status the status
6690            * @param start the lower bound of the range of journal articles
6691            * @param end the upper bound of the range of journal articles (not inclusive)
6692            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6693            * @return the ordered range of matching journal articles
6694            * @throws SystemException if a system exception occurred
6695            */
6696            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6697                    long groupId, java.lang.String articleId, int status, int start,
6698                    int end,
6699                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6700                    throws com.liferay.portal.kernel.exception.SystemException {
6701                    return getPersistence()
6702                                       .findByG_A_ST(groupId, articleId, status, start, end,
6703                            orderByComparator);
6704            }
6705    
6706            /**
6707            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6708            *
6709            * @param groupId the group ID
6710            * @param articleId the article ID
6711            * @param status the status
6712            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6713            * @return the first matching journal article
6714            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6715            * @throws SystemException if a system exception occurred
6716            */
6717            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
6718                    long groupId, java.lang.String articleId, int status,
6719                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6720                    throws com.liferay.portal.kernel.exception.SystemException,
6721                            com.liferay.portlet.journal.NoSuchArticleException {
6722                    return getPersistence()
6723                                       .findByG_A_ST_First(groupId, articleId, status,
6724                            orderByComparator);
6725            }
6726    
6727            /**
6728            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6729            *
6730            * @param groupId the group ID
6731            * @param articleId the article ID
6732            * @param status the status
6733            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6734            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6735            * @throws SystemException if a system exception occurred
6736            */
6737            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
6738                    long groupId, java.lang.String articleId, int status,
6739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6740                    throws com.liferay.portal.kernel.exception.SystemException {
6741                    return getPersistence()
6742                                       .fetchByG_A_ST_First(groupId, articleId, status,
6743                            orderByComparator);
6744            }
6745    
6746            /**
6747            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6748            *
6749            * @param groupId the group ID
6750            * @param articleId the article ID
6751            * @param status the status
6752            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6753            * @return the last matching journal article
6754            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6755            * @throws SystemException if a system exception occurred
6756            */
6757            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
6758                    long groupId, java.lang.String articleId, int status,
6759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6760                    throws com.liferay.portal.kernel.exception.SystemException,
6761                            com.liferay.portlet.journal.NoSuchArticleException {
6762                    return getPersistence()
6763                                       .findByG_A_ST_Last(groupId, articleId, status,
6764                            orderByComparator);
6765            }
6766    
6767            /**
6768            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6769            *
6770            * @param groupId the group ID
6771            * @param articleId the article ID
6772            * @param status the status
6773            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6774            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6775            * @throws SystemException if a system exception occurred
6776            */
6777            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
6778                    long groupId, java.lang.String articleId, int status,
6779                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6780                    throws com.liferay.portal.kernel.exception.SystemException {
6781                    return getPersistence()
6782                                       .fetchByG_A_ST_Last(groupId, articleId, status,
6783                            orderByComparator);
6784            }
6785    
6786            /**
6787            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6788            *
6789            * @param id the primary key of the current journal article
6790            * @param groupId the group ID
6791            * @param articleId the article ID
6792            * @param status the status
6793            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6794            * @return the previous, current, and next journal article
6795            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6796            * @throws SystemException if a system exception occurred
6797            */
6798            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
6799                    long id, long groupId, java.lang.String articleId, int status,
6800                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6801                    throws com.liferay.portal.kernel.exception.SystemException,
6802                            com.liferay.portlet.journal.NoSuchArticleException {
6803                    return getPersistence()
6804                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
6805                            orderByComparator);
6806            }
6807    
6808            /**
6809            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6810            *
6811            * @param groupId the group ID
6812            * @param articleId the article ID
6813            * @param status the status
6814            * @return the matching journal articles that the user has permission to view
6815            * @throws SystemException if a system exception occurred
6816            */
6817            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6818                    long groupId, java.lang.String articleId, int status)
6819                    throws com.liferay.portal.kernel.exception.SystemException {
6820                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
6821            }
6822    
6823            /**
6824            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6825            *
6826            * <p>
6827            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6828            * </p>
6829            *
6830            * @param groupId the group ID
6831            * @param articleId the article ID
6832            * @param status the status
6833            * @param start the lower bound of the range of journal articles
6834            * @param end the upper bound of the range of journal articles (not inclusive)
6835            * @return the range of matching journal articles that the user has permission to view
6836            * @throws SystemException if a system exception occurred
6837            */
6838            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6839                    long groupId, java.lang.String articleId, int status, int start, int end)
6840                    throws com.liferay.portal.kernel.exception.SystemException {
6841                    return getPersistence()
6842                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
6843            }
6844    
6845            /**
6846            * 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;.
6847            *
6848            * <p>
6849            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6850            * </p>
6851            *
6852            * @param groupId the group ID
6853            * @param articleId the article ID
6854            * @param status the status
6855            * @param start the lower bound of the range of journal articles
6856            * @param end the upper bound of the range of journal articles (not inclusive)
6857            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6858            * @return the ordered range of matching journal articles that the user has permission to view
6859            * @throws SystemException if a system exception occurred
6860            */
6861            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6862                    long groupId, java.lang.String articleId, int status, int start,
6863                    int end,
6864                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6865                    throws com.liferay.portal.kernel.exception.SystemException {
6866                    return getPersistence()
6867                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
6868                            orderByComparator);
6869            }
6870    
6871            /**
6872            * 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;.
6873            *
6874            * @param id the primary key of the current journal article
6875            * @param groupId the group ID
6876            * @param articleId the article ID
6877            * @param status the status
6878            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6879            * @return the previous, current, and next journal article
6880            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6881            * @throws SystemException if a system exception occurred
6882            */
6883            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
6884                    long id, long groupId, java.lang.String articleId, int status,
6885                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6886                    throws com.liferay.portal.kernel.exception.SystemException,
6887                            com.liferay.portlet.journal.NoSuchArticleException {
6888                    return getPersistence()
6889                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
6890                            status, orderByComparator);
6891            }
6892    
6893            /**
6894            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6895            *
6896            * @param groupId the group ID
6897            * @param articleId the article ID
6898            * @param statuses the statuses
6899            * @return the matching journal articles that the user has permission to view
6900            * @throws SystemException if a system exception occurred
6901            */
6902            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6903                    long groupId, java.lang.String articleId, int[] statuses)
6904                    throws com.liferay.portal.kernel.exception.SystemException {
6905                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
6906            }
6907    
6908            /**
6909            * 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;.
6910            *
6911            * <p>
6912            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6913            * </p>
6914            *
6915            * @param groupId the group ID
6916            * @param articleId the article ID
6917            * @param statuses the statuses
6918            * @param start the lower bound of the range of journal articles
6919            * @param end the upper bound of the range of journal articles (not inclusive)
6920            * @return the range of matching journal articles that the user has permission to view
6921            * @throws SystemException if a system exception occurred
6922            */
6923            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6924                    long groupId, java.lang.String articleId, int[] statuses, int start,
6925                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6926                    return getPersistence()
6927                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
6928            }
6929    
6930            /**
6931            * 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;.
6932            *
6933            * <p>
6934            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6935            * </p>
6936            *
6937            * @param groupId the group ID
6938            * @param articleId the article ID
6939            * @param statuses the statuses
6940            * @param start the lower bound of the range of journal articles
6941            * @param end the upper bound of the range of journal articles (not inclusive)
6942            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6943            * @return the ordered range of matching journal articles that the user has permission to view
6944            * @throws SystemException if a system exception occurred
6945            */
6946            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6947                    long groupId, java.lang.String articleId, int[] statuses, int start,
6948                    int end,
6949                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6950                    throws com.liferay.portal.kernel.exception.SystemException {
6951                    return getPersistence()
6952                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
6953                            end, orderByComparator);
6954            }
6955    
6956            /**
6957            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6958            *
6959            * <p>
6960            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6961            * </p>
6962            *
6963            * @param groupId the group ID
6964            * @param articleId the article ID
6965            * @param statuses the statuses
6966            * @return the matching journal articles
6967            * @throws SystemException if a system exception occurred
6968            */
6969            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6970                    long groupId, java.lang.String articleId, int[] statuses)
6971                    throws com.liferay.portal.kernel.exception.SystemException {
6972                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
6973            }
6974    
6975            /**
6976            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6977            *
6978            * <p>
6979            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6980            * </p>
6981            *
6982            * @param groupId the group ID
6983            * @param articleId the article ID
6984            * @param statuses the statuses
6985            * @param start the lower bound of the range of journal articles
6986            * @param end the upper bound of the range of journal articles (not inclusive)
6987            * @return the range of matching journal articles
6988            * @throws SystemException if a system exception occurred
6989            */
6990            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6991                    long groupId, java.lang.String articleId, int[] statuses, int start,
6992                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6993                    return getPersistence()
6994                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
6995            }
6996    
6997            /**
6998            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6999            *
7000            * <p>
7001            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7002            * </p>
7003            *
7004            * @param groupId the group ID
7005            * @param articleId the article ID
7006            * @param statuses the statuses
7007            * @param start the lower bound of the range of journal articles
7008            * @param end the upper bound of the range of journal articles (not inclusive)
7009            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7010            * @return the ordered range of matching journal articles
7011            * @throws SystemException if a system exception occurred
7012            */
7013            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7014                    long groupId, java.lang.String articleId, int[] statuses, int start,
7015                    int end,
7016                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7017                    throws com.liferay.portal.kernel.exception.SystemException {
7018                    return getPersistence()
7019                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
7020                            orderByComparator);
7021            }
7022    
7023            /**
7024            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
7025            *
7026            * @param groupId the group ID
7027            * @param articleId the article ID
7028            * @param status the status
7029            * @throws SystemException if a system exception occurred
7030            */
7031            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
7032                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7033                    getPersistence().removeByG_A_ST(groupId, articleId, status);
7034            }
7035    
7036            /**
7037            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7038            *
7039            * @param groupId the group ID
7040            * @param articleId the article ID
7041            * @param status the status
7042            * @return the number of matching journal articles
7043            * @throws SystemException if a system exception occurred
7044            */
7045            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7046                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7047                    return getPersistence().countByG_A_ST(groupId, articleId, status);
7048            }
7049    
7050            /**
7051            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7052            *
7053            * @param groupId the group ID
7054            * @param articleId the article ID
7055            * @param statuses the statuses
7056            * @return the number of matching journal articles
7057            * @throws SystemException if a system exception occurred
7058            */
7059            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7060                    int[] statuses)
7061                    throws com.liferay.portal.kernel.exception.SystemException {
7062                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
7063            }
7064    
7065            /**
7066            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7067            *
7068            * @param groupId the group ID
7069            * @param articleId the article ID
7070            * @param status the status
7071            * @return the number of matching journal articles that the user has permission to view
7072            * @throws SystemException if a system exception occurred
7073            */
7074            public static int filterCountByG_A_ST(long groupId,
7075                    java.lang.String articleId, int status)
7076                    throws com.liferay.portal.kernel.exception.SystemException {
7077                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
7078            }
7079    
7080            /**
7081            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7082            *
7083            * @param groupId the group ID
7084            * @param articleId the article ID
7085            * @param statuses the statuses
7086            * @return the number of matching journal articles that the user has permission to view
7087            * @throws SystemException if a system exception occurred
7088            */
7089            public static int filterCountByG_A_ST(long groupId,
7090                    java.lang.String articleId, int[] statuses)
7091                    throws com.liferay.portal.kernel.exception.SystemException {
7092                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
7093            }
7094    
7095            /**
7096            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7097            *
7098            * @param groupId the group ID
7099            * @param urlTitle the url title
7100            * @param status the status
7101            * @return the matching journal articles
7102            * @throws SystemException if a system exception occurred
7103            */
7104            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7105                    long groupId, java.lang.String urlTitle, int status)
7106                    throws com.liferay.portal.kernel.exception.SystemException {
7107                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
7108            }
7109    
7110            /**
7111            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7112            *
7113            * <p>
7114            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7115            * </p>
7116            *
7117            * @param groupId the group ID
7118            * @param urlTitle the url title
7119            * @param status the status
7120            * @param start the lower bound of the range of journal articles
7121            * @param end the upper bound of the range of journal articles (not inclusive)
7122            * @return the range of matching journal articles
7123            * @throws SystemException if a system exception occurred
7124            */
7125            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7126                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7127                    throws com.liferay.portal.kernel.exception.SystemException {
7128                    return getPersistence()
7129                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
7130            }
7131    
7132            /**
7133            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7134            *
7135            * <p>
7136            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7137            * </p>
7138            *
7139            * @param groupId the group ID
7140            * @param urlTitle the url title
7141            * @param status the status
7142            * @param start the lower bound of the range of journal articles
7143            * @param end the upper bound of the range of journal articles (not inclusive)
7144            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7145            * @return the ordered range of matching journal articles
7146            * @throws SystemException if a system exception occurred
7147            */
7148            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7149                    long groupId, java.lang.String urlTitle, int status, int start,
7150                    int end,
7151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7152                    throws com.liferay.portal.kernel.exception.SystemException {
7153                    return getPersistence()
7154                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
7155                            orderByComparator);
7156            }
7157    
7158            /**
7159            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7160            *
7161            * @param groupId the group ID
7162            * @param urlTitle the url title
7163            * @param status the status
7164            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7165            * @return the first matching journal article
7166            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7167            * @throws SystemException if a system exception occurred
7168            */
7169            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
7170                    long groupId, java.lang.String urlTitle, int status,
7171                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7172                    throws com.liferay.portal.kernel.exception.SystemException,
7173                            com.liferay.portlet.journal.NoSuchArticleException {
7174                    return getPersistence()
7175                                       .findByG_UT_ST_First(groupId, urlTitle, status,
7176                            orderByComparator);
7177            }
7178    
7179            /**
7180            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7181            *
7182            * @param groupId the group ID
7183            * @param urlTitle the url title
7184            * @param status the status
7185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7186            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7187            * @throws SystemException if a system exception occurred
7188            */
7189            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
7190                    long groupId, java.lang.String urlTitle, int status,
7191                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7192                    throws com.liferay.portal.kernel.exception.SystemException {
7193                    return getPersistence()
7194                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
7195                            orderByComparator);
7196            }
7197    
7198            /**
7199            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7200            *
7201            * @param groupId the group ID
7202            * @param urlTitle the url title
7203            * @param status the status
7204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7205            * @return the last matching journal article
7206            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7207            * @throws SystemException if a system exception occurred
7208            */
7209            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
7210                    long groupId, java.lang.String urlTitle, int status,
7211                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7212                    throws com.liferay.portal.kernel.exception.SystemException,
7213                            com.liferay.portlet.journal.NoSuchArticleException {
7214                    return getPersistence()
7215                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
7216                            orderByComparator);
7217            }
7218    
7219            /**
7220            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7221            *
7222            * @param groupId the group ID
7223            * @param urlTitle the url title
7224            * @param status the status
7225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7226            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7227            * @throws SystemException if a system exception occurred
7228            */
7229            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
7230                    long groupId, java.lang.String urlTitle, int status,
7231                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7232                    throws com.liferay.portal.kernel.exception.SystemException {
7233                    return getPersistence()
7234                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
7235                            orderByComparator);
7236            }
7237    
7238            /**
7239            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7240            *
7241            * @param id the primary key of the current journal article
7242            * @param groupId the group ID
7243            * @param urlTitle the url title
7244            * @param status the status
7245            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7246            * @return the previous, current, and next journal article
7247            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7248            * @throws SystemException if a system exception occurred
7249            */
7250            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
7251                    long id, long groupId, java.lang.String urlTitle, int status,
7252                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7253                    throws com.liferay.portal.kernel.exception.SystemException,
7254                            com.liferay.portlet.journal.NoSuchArticleException {
7255                    return getPersistence()
7256                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
7257                            orderByComparator);
7258            }
7259    
7260            /**
7261            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7262            *
7263            * @param groupId the group ID
7264            * @param urlTitle the url title
7265            * @param status the status
7266            * @return the matching journal articles that the user has permission to view
7267            * @throws SystemException if a system exception occurred
7268            */
7269            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7270                    long groupId, java.lang.String urlTitle, int status)
7271                    throws com.liferay.portal.kernel.exception.SystemException {
7272                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
7273            }
7274    
7275            /**
7276            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7277            *
7278            * <p>
7279            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7280            * </p>
7281            *
7282            * @param groupId the group ID
7283            * @param urlTitle the url title
7284            * @param status the status
7285            * @param start the lower bound of the range of journal articles
7286            * @param end the upper bound of the range of journal articles (not inclusive)
7287            * @return the range of matching journal articles that the user has permission to view
7288            * @throws SystemException if a system exception occurred
7289            */
7290            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7291                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7292                    throws com.liferay.portal.kernel.exception.SystemException {
7293                    return getPersistence()
7294                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7295            }
7296    
7297            /**
7298            * 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;.
7299            *
7300            * <p>
7301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7302            * </p>
7303            *
7304            * @param groupId the group ID
7305            * @param urlTitle the url title
7306            * @param status the status
7307            * @param start the lower bound of the range of journal articles
7308            * @param end the upper bound of the range of journal articles (not inclusive)
7309            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7310            * @return the ordered range of matching journal articles that the user has permission to view
7311            * @throws SystemException if a system exception occurred
7312            */
7313            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7314                    long groupId, java.lang.String urlTitle, int status, int start,
7315                    int end,
7316                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7317                    throws com.liferay.portal.kernel.exception.SystemException {
7318                    return getPersistence()
7319                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7320                            orderByComparator);
7321            }
7322    
7323            /**
7324            * 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;.
7325            *
7326            * @param id the primary key of the current journal article
7327            * @param groupId the group ID
7328            * @param urlTitle the url title
7329            * @param status the status
7330            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7331            * @return the previous, current, and next journal article
7332            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7333            * @throws SystemException if a system exception occurred
7334            */
7335            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
7336                    long id, long groupId, java.lang.String urlTitle, int status,
7337                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7338                    throws com.liferay.portal.kernel.exception.SystemException,
7339                            com.liferay.portlet.journal.NoSuchArticleException {
7340                    return getPersistence()
7341                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7342                            status, orderByComparator);
7343            }
7344    
7345            /**
7346            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7347            *
7348            * @param groupId the group ID
7349            * @param urlTitle the url title
7350            * @param status the status
7351            * @throws SystemException if a system exception occurred
7352            */
7353            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7354                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7355                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7356            }
7357    
7358            /**
7359            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7360            *
7361            * @param groupId the group ID
7362            * @param urlTitle the url title
7363            * @param status the status
7364            * @return the number of matching journal articles
7365            * @throws SystemException if a system exception occurred
7366            */
7367            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7368                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7369                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7370            }
7371    
7372            /**
7373            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7374            *
7375            * @param groupId the group ID
7376            * @param urlTitle the url title
7377            * @param status the status
7378            * @return the number of matching journal articles that the user has permission to view
7379            * @throws SystemException if a system exception occurred
7380            */
7381            public static int filterCountByG_UT_ST(long groupId,
7382                    java.lang.String urlTitle, int status)
7383                    throws com.liferay.portal.kernel.exception.SystemException {
7384                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7385            }
7386    
7387            /**
7388            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7389            *
7390            * @param companyId the company ID
7391            * @param version the version
7392            * @param status the status
7393            * @return the matching journal articles
7394            * @throws SystemException if a system exception occurred
7395            */
7396            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7397                    long companyId, double version, int status)
7398                    throws com.liferay.portal.kernel.exception.SystemException {
7399                    return getPersistence().findByC_V_ST(companyId, version, status);
7400            }
7401    
7402            /**
7403            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7404            *
7405            * <p>
7406            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7407            * </p>
7408            *
7409            * @param companyId the company ID
7410            * @param version the version
7411            * @param status the status
7412            * @param start the lower bound of the range of journal articles
7413            * @param end the upper bound of the range of journal articles (not inclusive)
7414            * @return the range of matching journal articles
7415            * @throws SystemException if a system exception occurred
7416            */
7417            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7418                    long companyId, double version, int status, int start, int end)
7419                    throws com.liferay.portal.kernel.exception.SystemException {
7420                    return getPersistence()
7421                                       .findByC_V_ST(companyId, version, status, start, end);
7422            }
7423    
7424            /**
7425            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7426            *
7427            * <p>
7428            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7429            * </p>
7430            *
7431            * @param companyId the company ID
7432            * @param version the version
7433            * @param status the status
7434            * @param start the lower bound of the range of journal articles
7435            * @param end the upper bound of the range of journal articles (not inclusive)
7436            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7437            * @return the ordered range of matching journal articles
7438            * @throws SystemException if a system exception occurred
7439            */
7440            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7441                    long companyId, double version, int status, int start, int end,
7442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7443                    throws com.liferay.portal.kernel.exception.SystemException {
7444                    return getPersistence()
7445                                       .findByC_V_ST(companyId, version, status, start, end,
7446                            orderByComparator);
7447            }
7448    
7449            /**
7450            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7451            *
7452            * @param companyId the company ID
7453            * @param version the version
7454            * @param status the status
7455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7456            * @return the first matching journal article
7457            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7458            * @throws SystemException if a system exception occurred
7459            */
7460            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
7461                    long companyId, double version, int status,
7462                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7463                    throws com.liferay.portal.kernel.exception.SystemException,
7464                            com.liferay.portlet.journal.NoSuchArticleException {
7465                    return getPersistence()
7466                                       .findByC_V_ST_First(companyId, version, status,
7467                            orderByComparator);
7468            }
7469    
7470            /**
7471            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7472            *
7473            * @param companyId the company ID
7474            * @param version the version
7475            * @param status the status
7476            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7477            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7478            * @throws SystemException if a system exception occurred
7479            */
7480            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
7481                    long companyId, double version, int status,
7482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7483                    throws com.liferay.portal.kernel.exception.SystemException {
7484                    return getPersistence()
7485                                       .fetchByC_V_ST_First(companyId, version, status,
7486                            orderByComparator);
7487            }
7488    
7489            /**
7490            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7491            *
7492            * @param companyId the company ID
7493            * @param version the version
7494            * @param status the status
7495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7496            * @return the last matching journal article
7497            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7498            * @throws SystemException if a system exception occurred
7499            */
7500            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
7501                    long companyId, double version, int status,
7502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7503                    throws com.liferay.portal.kernel.exception.SystemException,
7504                            com.liferay.portlet.journal.NoSuchArticleException {
7505                    return getPersistence()
7506                                       .findByC_V_ST_Last(companyId, version, status,
7507                            orderByComparator);
7508            }
7509    
7510            /**
7511            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7512            *
7513            * @param companyId the company ID
7514            * @param version the version
7515            * @param status the status
7516            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7517            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7518            * @throws SystemException if a system exception occurred
7519            */
7520            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
7521                    long companyId, double version, int status,
7522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7523                    throws com.liferay.portal.kernel.exception.SystemException {
7524                    return getPersistence()
7525                                       .fetchByC_V_ST_Last(companyId, version, status,
7526                            orderByComparator);
7527            }
7528    
7529            /**
7530            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7531            *
7532            * @param id the primary key of the current journal article
7533            * @param companyId the company ID
7534            * @param version the version
7535            * @param status the status
7536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7537            * @return the previous, current, and next journal article
7538            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7539            * @throws SystemException if a system exception occurred
7540            */
7541            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
7542                    long id, long companyId, double version, int status,
7543                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7544                    throws com.liferay.portal.kernel.exception.SystemException,
7545                            com.liferay.portlet.journal.NoSuchArticleException {
7546                    return getPersistence()
7547                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7548                            orderByComparator);
7549            }
7550    
7551            /**
7552            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7553            *
7554            * @param companyId the company ID
7555            * @param version the version
7556            * @param status the status
7557            * @throws SystemException if a system exception occurred
7558            */
7559            public static void removeByC_V_ST(long companyId, double version, int status)
7560                    throws com.liferay.portal.kernel.exception.SystemException {
7561                    getPersistence().removeByC_V_ST(companyId, version, status);
7562            }
7563    
7564            /**
7565            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7566            *
7567            * @param companyId the company ID
7568            * @param version the version
7569            * @param status the status
7570            * @return the number of matching journal articles
7571            * @throws SystemException if a system exception occurred
7572            */
7573            public static int countByC_V_ST(long companyId, double version, int status)
7574                    throws com.liferay.portal.kernel.exception.SystemException {
7575                    return getPersistence().countByC_V_ST(companyId, version, status);
7576            }
7577    
7578            /**
7579            * Caches the journal article in the entity cache if it is enabled.
7580            *
7581            * @param journalArticle the journal article
7582            */
7583            public static void cacheResult(
7584                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7585                    getPersistence().cacheResult(journalArticle);
7586            }
7587    
7588            /**
7589            * Caches the journal articles in the entity cache if it is enabled.
7590            *
7591            * @param journalArticles the journal articles
7592            */
7593            public static void cacheResult(
7594                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
7595                    getPersistence().cacheResult(journalArticles);
7596            }
7597    
7598            /**
7599            * Creates a new journal article with the primary key. Does not add the journal article to the database.
7600            *
7601            * @param id the primary key for the new journal article
7602            * @return the new journal article
7603            */
7604            public static com.liferay.portlet.journal.model.JournalArticle create(
7605                    long id) {
7606                    return getPersistence().create(id);
7607            }
7608    
7609            /**
7610            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
7611            *
7612            * @param id the primary key of the journal article
7613            * @return the journal article that was removed
7614            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7615            * @throws SystemException if a system exception occurred
7616            */
7617            public static com.liferay.portlet.journal.model.JournalArticle remove(
7618                    long id)
7619                    throws com.liferay.portal.kernel.exception.SystemException,
7620                            com.liferay.portlet.journal.NoSuchArticleException {
7621                    return getPersistence().remove(id);
7622            }
7623    
7624            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
7625                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
7626                    throws com.liferay.portal.kernel.exception.SystemException {
7627                    return getPersistence().updateImpl(journalArticle);
7628            }
7629    
7630            /**
7631            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
7632            *
7633            * @param id the primary key of the journal article
7634            * @return the journal article
7635            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7636            * @throws SystemException if a system exception occurred
7637            */
7638            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
7639                    long id)
7640                    throws com.liferay.portal.kernel.exception.SystemException,
7641                            com.liferay.portlet.journal.NoSuchArticleException {
7642                    return getPersistence().findByPrimaryKey(id);
7643            }
7644    
7645            /**
7646            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
7647            *
7648            * @param id the primary key of the journal article
7649            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
7650            * @throws SystemException if a system exception occurred
7651            */
7652            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
7653                    long id) throws com.liferay.portal.kernel.exception.SystemException {
7654                    return getPersistence().fetchByPrimaryKey(id);
7655            }
7656    
7657            /**
7658            * Returns all the journal articles.
7659            *
7660            * @return the journal articles
7661            * @throws SystemException if a system exception occurred
7662            */
7663            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
7664                    throws com.liferay.portal.kernel.exception.SystemException {
7665                    return getPersistence().findAll();
7666            }
7667    
7668            /**
7669            * Returns a range of all the journal articles.
7670            *
7671            * <p>
7672            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7673            * </p>
7674            *
7675            * @param start the lower bound of the range of journal articles
7676            * @param end the upper bound of the range of journal articles (not inclusive)
7677            * @return the range of journal articles
7678            * @throws SystemException if a system exception occurred
7679            */
7680            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7681                    int start, int end)
7682                    throws com.liferay.portal.kernel.exception.SystemException {
7683                    return getPersistence().findAll(start, end);
7684            }
7685    
7686            /**
7687            * Returns an ordered range of all the journal articles.
7688            *
7689            * <p>
7690            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7691            * </p>
7692            *
7693            * @param start the lower bound of the range of journal articles
7694            * @param end the upper bound of the range of journal articles (not inclusive)
7695            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7696            * @return the ordered range of journal articles
7697            * @throws SystemException if a system exception occurred
7698            */
7699            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7700                    int start, int end,
7701                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7702                    throws com.liferay.portal.kernel.exception.SystemException {
7703                    return getPersistence().findAll(start, end, orderByComparator);
7704            }
7705    
7706            /**
7707            * Removes all the journal articles from the database.
7708            *
7709            * @throws SystemException if a system exception occurred
7710            */
7711            public static void removeAll()
7712                    throws com.liferay.portal.kernel.exception.SystemException {
7713                    getPersistence().removeAll();
7714            }
7715    
7716            /**
7717            * Returns the number of journal articles.
7718            *
7719            * @return the number of journal articles
7720            * @throws SystemException if a system exception occurred
7721            */
7722            public static int countAll()
7723                    throws com.liferay.portal.kernel.exception.SystemException {
7724                    return getPersistence().countAll();
7725            }
7726    
7727            public static JournalArticlePersistence getPersistence() {
7728                    if (_persistence == null) {
7729                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
7730    
7731                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
7732                                    "_persistence");
7733                    }
7734    
7735                    return _persistence;
7736            }
7737    
7738            /**
7739             * @deprecated
7740             */
7741            public void setPersistence(JournalArticlePersistence persistence) {
7742            }
7743    
7744            private static JournalArticlePersistence _persistence;
7745    }