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 classNameId = &#63; and classPK = &#63;.
5018            *
5019            * @param groupId the group ID
5020            * @param classNameId the class name ID
5021            * @param classPK the class p k
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_C_C(
5026                    long groupId, long classNameId, long classPK)
5027                    throws com.liferay.portal.kernel.exception.SystemException {
5028                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5029            }
5030    
5031            /**
5032            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#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 classNameId the class name ID
5040            * @param classPK the class p k
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_C_C(
5047                    long groupId, long classNameId, long classPK, int start, int end)
5048                    throws com.liferay.portal.kernel.exception.SystemException {
5049                    return getPersistence()
5050                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5051            }
5052    
5053            /**
5054            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#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 classNameId the class name ID
5062            * @param classPK the class p k
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_C_C(
5070                    long groupId, long classNameId, long classPK, 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_C_C(groupId, classNameId, classPK, start, end,
5075                            orderByComparator);
5076            }
5077    
5078            /**
5079            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5080            *
5081            * @param groupId the group ID
5082            * @param classNameId the class name ID
5083            * @param classPK the class p k
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_C_C_First(
5090                    long groupId, long classNameId, long classPK,
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_C_C_First(groupId, classNameId, classPK,
5096                            orderByComparator);
5097            }
5098    
5099            /**
5100            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5101            *
5102            * @param groupId the group ID
5103            * @param classNameId the class name ID
5104            * @param classPK the class p k
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_C_C_First(
5110                    long groupId, long classNameId, long classPK,
5111                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5112                    throws com.liferay.portal.kernel.exception.SystemException {
5113                    return getPersistence()
5114                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5115                            orderByComparator);
5116            }
5117    
5118            /**
5119            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5120            *
5121            * @param groupId the group ID
5122            * @param classNameId the class name ID
5123            * @param classPK the class p k
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_C_C_Last(
5130                    long groupId, long classNameId, long classPK,
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_C_C_Last(groupId, classNameId, classPK,
5136                            orderByComparator);
5137            }
5138    
5139            /**
5140            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5141            *
5142            * @param groupId the group ID
5143            * @param classNameId the class name ID
5144            * @param classPK the class p k
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_C_C_Last(
5150                    long groupId, long classNameId, long classPK,
5151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5152                    throws com.liferay.portal.kernel.exception.SystemException {
5153                    return getPersistence()
5154                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
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 classNameId = &#63; and classPK = &#63;.
5160            *
5161            * @param id the primary key of the current journal article
5162            * @param groupId the group ID
5163            * @param classNameId the class name ID
5164            * @param classPK the class p k
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_C_C_PrevAndNext(
5171                    long id, long groupId, long classNameId, long classPK,
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_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5177                            orderByComparator);
5178            }
5179    
5180            /**
5181            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5182            *
5183            * @param groupId the group ID
5184            * @param classNameId the class name ID
5185            * @param classPK the class p k
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_C_C(
5190                    long groupId, long classNameId, long classPK)
5191                    throws com.liferay.portal.kernel.exception.SystemException {
5192                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5193            }
5194    
5195            /**
5196            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#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 classNameId the class name ID
5204            * @param classPK the class p k
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_C_C(
5211                    long groupId, long classNameId, long classPK, int start, int end)
5212                    throws com.liferay.portal.kernel.exception.SystemException {
5213                    return getPersistence()
5214                                       .filterFindByG_C_C(groupId, classNameId, classPK, 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 classNameId = &#63; and classPK = &#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 classNameId the class name ID
5226            * @param classPK the class p k
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_C_C(
5234                    long groupId, long classNameId, long classPK, 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_C_C(groupId, classNameId, classPK, 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 classNameId = &#63; and classPK = &#63;.
5244            *
5245            * @param id the primary key of the current journal article
5246            * @param groupId the group ID
5247            * @param classNameId the class name ID
5248            * @param classPK the class p k
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_C_C_PrevAndNext(
5255                    long id, long groupId, long classNameId, long classPK,
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_C_C_PrevAndNext(id, groupId, classNameId,
5261                            classPK, orderByComparator);
5262            }
5263    
5264            /**
5265            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5266            *
5267            * @param groupId the group ID
5268            * @param classNameId the class name ID
5269            * @param classPK the class p k
5270            * @throws SystemException if a system exception occurred
5271            */
5272            public static void removeByG_C_C(long groupId, long classNameId,
5273                    long classPK)
5274                    throws com.liferay.portal.kernel.exception.SystemException {
5275                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5276            }
5277    
5278            /**
5279            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5280            *
5281            * @param groupId the group ID
5282            * @param classNameId the class name ID
5283            * @param classPK the class p k
5284            * @return the number of matching journal articles
5285            * @throws SystemException if a system exception occurred
5286            */
5287            public static int countByG_C_C(long groupId, long classNameId, long classPK)
5288                    throws com.liferay.portal.kernel.exception.SystemException {
5289                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5290            }
5291    
5292            /**
5293            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5294            *
5295            * @param groupId the group ID
5296            * @param classNameId the class name ID
5297            * @param classPK the class p k
5298            * @return the number of matching journal articles that the user has permission to view
5299            * @throws SystemException if a system exception occurred
5300            */
5301            public static int filterCountByG_C_C(long groupId, long classNameId,
5302                    long classPK)
5303                    throws com.liferay.portal.kernel.exception.SystemException {
5304                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5305            }
5306    
5307            /**
5308            * 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.
5309            *
5310            * @param groupId the group ID
5311            * @param classNameId the class name ID
5312            * @param structureId the structure ID
5313            * @return the matching journal article
5314            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5315            * @throws SystemException if a system exception occurred
5316            */
5317            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
5318                    long groupId, long classNameId, java.lang.String structureId)
5319                    throws com.liferay.portal.kernel.exception.SystemException,
5320                            com.liferay.portlet.journal.NoSuchArticleException {
5321                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
5322            }
5323    
5324            /**
5325            * 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.
5326            *
5327            * @param groupId the group ID
5328            * @param classNameId the class name ID
5329            * @param structureId the structure ID
5330            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5331            * @throws SystemException if a system exception occurred
5332            */
5333            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5334                    long groupId, long classNameId, java.lang.String structureId)
5335                    throws com.liferay.portal.kernel.exception.SystemException {
5336                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
5337            }
5338    
5339            /**
5340            * 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.
5341            *
5342            * @param groupId the group ID
5343            * @param classNameId the class name ID
5344            * @param structureId the structure ID
5345            * @param retrieveFromCache whether to use the finder cache
5346            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5347            * @throws SystemException if a system exception occurred
5348            */
5349            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5350                    long groupId, long classNameId, java.lang.String structureId,
5351                    boolean retrieveFromCache)
5352                    throws com.liferay.portal.kernel.exception.SystemException {
5353                    return getPersistence()
5354                                       .fetchByG_C_S(groupId, classNameId, structureId,
5355                            retrieveFromCache);
5356            }
5357    
5358            /**
5359            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
5360            *
5361            * @param groupId the group ID
5362            * @param classNameId the class name ID
5363            * @param structureId the structure ID
5364            * @return the journal article that was removed
5365            * @throws SystemException if a system exception occurred
5366            */
5367            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
5368                    long groupId, long classNameId, java.lang.String structureId)
5369                    throws com.liferay.portal.kernel.exception.SystemException,
5370                            com.liferay.portlet.journal.NoSuchArticleException {
5371                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
5372            }
5373    
5374            /**
5375            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
5376            *
5377            * @param groupId the group ID
5378            * @param classNameId the class name ID
5379            * @param structureId the structure ID
5380            * @return the number of matching journal articles
5381            * @throws SystemException if a system exception occurred
5382            */
5383            public static int countByG_C_S(long groupId, long classNameId,
5384                    java.lang.String structureId)
5385                    throws com.liferay.portal.kernel.exception.SystemException {
5386                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
5387            }
5388    
5389            /**
5390            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5391            *
5392            * @param groupId the group ID
5393            * @param classNameId the class name ID
5394            * @param templateId the template ID
5395            * @return the matching journal articles
5396            * @throws SystemException if a system exception occurred
5397            */
5398            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5399                    long groupId, long classNameId, java.lang.String templateId)
5400                    throws com.liferay.portal.kernel.exception.SystemException {
5401                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
5402            }
5403    
5404            /**
5405            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5406            *
5407            * <p>
5408            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5409            * </p>
5410            *
5411            * @param groupId the group ID
5412            * @param classNameId the class name ID
5413            * @param templateId the template ID
5414            * @param start the lower bound of the range of journal articles
5415            * @param end the upper bound of the range of journal articles (not inclusive)
5416            * @return the range of matching journal articles
5417            * @throws SystemException if a system exception occurred
5418            */
5419            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5420                    long groupId, long classNameId, java.lang.String templateId, int start,
5421                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5422                    return getPersistence()
5423                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
5424            }
5425    
5426            /**
5427            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5428            *
5429            * <p>
5430            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5431            * </p>
5432            *
5433            * @param groupId the group ID
5434            * @param classNameId the class name ID
5435            * @param templateId the template ID
5436            * @param start the lower bound of the range of journal articles
5437            * @param end the upper bound of the range of journal articles (not inclusive)
5438            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5439            * @return the ordered range of matching journal articles
5440            * @throws SystemException if a system exception occurred
5441            */
5442            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5443                    long groupId, long classNameId, java.lang.String templateId, int start,
5444                    int end,
5445                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5446                    throws com.liferay.portal.kernel.exception.SystemException {
5447                    return getPersistence()
5448                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
5449                            orderByComparator);
5450            }
5451    
5452            /**
5453            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5454            *
5455            * @param groupId the group ID
5456            * @param classNameId the class name ID
5457            * @param templateId the template ID
5458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5459            * @return the first matching journal article
5460            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5461            * @throws SystemException if a system exception occurred
5462            */
5463            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
5464                    long groupId, long classNameId, java.lang.String templateId,
5465                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5466                    throws com.liferay.portal.kernel.exception.SystemException,
5467                            com.liferay.portlet.journal.NoSuchArticleException {
5468                    return getPersistence()
5469                                       .findByG_C_T_First(groupId, classNameId, templateId,
5470                            orderByComparator);
5471            }
5472    
5473            /**
5474            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5475            *
5476            * @param groupId the group ID
5477            * @param classNameId the class name ID
5478            * @param templateId the template ID
5479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5480            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5481            * @throws SystemException if a system exception occurred
5482            */
5483            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
5484                    long groupId, long classNameId, java.lang.String templateId,
5485                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5486                    throws com.liferay.portal.kernel.exception.SystemException {
5487                    return getPersistence()
5488                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
5489                            orderByComparator);
5490            }
5491    
5492            /**
5493            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5494            *
5495            * @param groupId the group ID
5496            * @param classNameId the class name ID
5497            * @param templateId the template ID
5498            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5499            * @return the last matching journal article
5500            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5501            * @throws SystemException if a system exception occurred
5502            */
5503            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
5504                    long groupId, long classNameId, java.lang.String templateId,
5505                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5506                    throws com.liferay.portal.kernel.exception.SystemException,
5507                            com.liferay.portlet.journal.NoSuchArticleException {
5508                    return getPersistence()
5509                                       .findByG_C_T_Last(groupId, classNameId, templateId,
5510                            orderByComparator);
5511            }
5512    
5513            /**
5514            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5515            *
5516            * @param groupId the group ID
5517            * @param classNameId the class name ID
5518            * @param templateId the template ID
5519            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5520            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5521            * @throws SystemException if a system exception occurred
5522            */
5523            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
5524                    long groupId, long classNameId, java.lang.String templateId,
5525                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5526                    throws com.liferay.portal.kernel.exception.SystemException {
5527                    return getPersistence()
5528                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
5529                            orderByComparator);
5530            }
5531    
5532            /**
5533            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5534            *
5535            * @param id the primary key of the current journal article
5536            * @param groupId the group ID
5537            * @param classNameId the class name ID
5538            * @param templateId the template ID
5539            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5540            * @return the previous, current, and next journal article
5541            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5542            * @throws SystemException if a system exception occurred
5543            */
5544            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
5545                    long id, long groupId, long classNameId, java.lang.String templateId,
5546                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5547                    throws com.liferay.portal.kernel.exception.SystemException,
5548                            com.liferay.portlet.journal.NoSuchArticleException {
5549                    return getPersistence()
5550                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
5551                            templateId, orderByComparator);
5552            }
5553    
5554            /**
5555            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5556            *
5557            * @param groupId the group ID
5558            * @param classNameId the class name ID
5559            * @param templateId the template ID
5560            * @return the matching journal articles that the user has permission to view
5561            * @throws SystemException if a system exception occurred
5562            */
5563            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5564                    long groupId, long classNameId, java.lang.String templateId)
5565                    throws com.liferay.portal.kernel.exception.SystemException {
5566                    return getPersistence()
5567                                       .filterFindByG_C_T(groupId, classNameId, templateId);
5568            }
5569    
5570            /**
5571            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5572            *
5573            * <p>
5574            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5575            * </p>
5576            *
5577            * @param groupId the group ID
5578            * @param classNameId the class name ID
5579            * @param templateId the template ID
5580            * @param start the lower bound of the range of journal articles
5581            * @param end the upper bound of the range of journal articles (not inclusive)
5582            * @return the range of matching journal articles that the user has permission to view
5583            * @throws SystemException if a system exception occurred
5584            */
5585            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5586                    long groupId, long classNameId, java.lang.String templateId, int start,
5587                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5588                    return getPersistence()
5589                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
5590                            end);
5591            }
5592    
5593            /**
5594            * 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;.
5595            *
5596            * <p>
5597            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5598            * </p>
5599            *
5600            * @param groupId the group ID
5601            * @param classNameId the class name ID
5602            * @param templateId the template ID
5603            * @param start the lower bound of the range of journal articles
5604            * @param end the upper bound of the range of journal articles (not inclusive)
5605            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5606            * @return the ordered range of matching journal articles that the user has permission to view
5607            * @throws SystemException if a system exception occurred
5608            */
5609            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5610                    long groupId, long classNameId, java.lang.String templateId, int start,
5611                    int end,
5612                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5613                    throws com.liferay.portal.kernel.exception.SystemException {
5614                    return getPersistence()
5615                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
5616                            end, orderByComparator);
5617            }
5618    
5619            /**
5620            * 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;.
5621            *
5622            * @param id the primary key of the current journal article
5623            * @param groupId the group ID
5624            * @param classNameId the class name ID
5625            * @param templateId the template ID
5626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5627            * @return the previous, current, and next journal article
5628            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5629            * @throws SystemException if a system exception occurred
5630            */
5631            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
5632                    long id, long groupId, long classNameId, java.lang.String templateId,
5633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5634                    throws com.liferay.portal.kernel.exception.SystemException,
5635                            com.liferay.portlet.journal.NoSuchArticleException {
5636                    return getPersistence()
5637                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
5638                            templateId, orderByComparator);
5639            }
5640    
5641            /**
5642            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
5643            *
5644            * @param groupId the group ID
5645            * @param classNameId the class name ID
5646            * @param templateId the template ID
5647            * @throws SystemException if a system exception occurred
5648            */
5649            public static void removeByG_C_T(long groupId, long classNameId,
5650                    java.lang.String templateId)
5651                    throws com.liferay.portal.kernel.exception.SystemException {
5652                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
5653            }
5654    
5655            /**
5656            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5657            *
5658            * @param groupId the group ID
5659            * @param classNameId the class name ID
5660            * @param templateId the template ID
5661            * @return the number of matching journal articles
5662            * @throws SystemException if a system exception occurred
5663            */
5664            public static int countByG_C_T(long groupId, long classNameId,
5665                    java.lang.String templateId)
5666                    throws com.liferay.portal.kernel.exception.SystemException {
5667                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
5668            }
5669    
5670            /**
5671            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5672            *
5673            * @param groupId the group ID
5674            * @param classNameId the class name ID
5675            * @param templateId the template ID
5676            * @return the number of matching journal articles that the user has permission to view
5677            * @throws SystemException if a system exception occurred
5678            */
5679            public static int filterCountByG_C_T(long groupId, long classNameId,
5680                    java.lang.String templateId)
5681                    throws com.liferay.portal.kernel.exception.SystemException {
5682                    return getPersistence()
5683                                       .filterCountByG_C_T(groupId, classNameId, templateId);
5684            }
5685    
5686            /**
5687            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5688            *
5689            * @param groupId the group ID
5690            * @param classNameId the class name ID
5691            * @param layoutUuid the layout uuid
5692            * @return the matching journal articles
5693            * @throws SystemException if a system exception occurred
5694            */
5695            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5696                    long groupId, long classNameId, java.lang.String layoutUuid)
5697                    throws com.liferay.portal.kernel.exception.SystemException {
5698                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
5699            }
5700    
5701            /**
5702            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5703            *
5704            * <p>
5705            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5706            * </p>
5707            *
5708            * @param groupId the group ID
5709            * @param classNameId the class name ID
5710            * @param layoutUuid the layout uuid
5711            * @param start the lower bound of the range of journal articles
5712            * @param end the upper bound of the range of journal articles (not inclusive)
5713            * @return the range of matching journal articles
5714            * @throws SystemException if a system exception occurred
5715            */
5716            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5717                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5718                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5719                    return getPersistence()
5720                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
5721            }
5722    
5723            /**
5724            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5725            *
5726            * <p>
5727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5728            * </p>
5729            *
5730            * @param groupId the group ID
5731            * @param classNameId the class name ID
5732            * @param layoutUuid the layout uuid
5733            * @param start the lower bound of the range of journal articles
5734            * @param end the upper bound of the range of journal articles (not inclusive)
5735            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5736            * @return the ordered range of matching journal articles
5737            * @throws SystemException if a system exception occurred
5738            */
5739            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5740                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5741                    int end,
5742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5743                    throws com.liferay.portal.kernel.exception.SystemException {
5744                    return getPersistence()
5745                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
5746                            orderByComparator);
5747            }
5748    
5749            /**
5750            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5751            *
5752            * @param groupId the group ID
5753            * @param classNameId the class name ID
5754            * @param layoutUuid the layout uuid
5755            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5756            * @return the first matching journal article
5757            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5758            * @throws SystemException if a system exception occurred
5759            */
5760            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
5761                    long groupId, long classNameId, java.lang.String layoutUuid,
5762                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5763                    throws com.liferay.portal.kernel.exception.SystemException,
5764                            com.liferay.portlet.journal.NoSuchArticleException {
5765                    return getPersistence()
5766                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
5767                            orderByComparator);
5768            }
5769    
5770            /**
5771            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5772            *
5773            * @param groupId the group ID
5774            * @param classNameId the class name ID
5775            * @param layoutUuid the layout uuid
5776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5777            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5778            * @throws SystemException if a system exception occurred
5779            */
5780            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
5781                    long groupId, long classNameId, java.lang.String layoutUuid,
5782                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5783                    throws com.liferay.portal.kernel.exception.SystemException {
5784                    return getPersistence()
5785                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
5786                            orderByComparator);
5787            }
5788    
5789            /**
5790            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5791            *
5792            * @param groupId the group ID
5793            * @param classNameId the class name ID
5794            * @param layoutUuid the layout uuid
5795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5796            * @return the last matching journal article
5797            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5798            * @throws SystemException if a system exception occurred
5799            */
5800            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
5801                    long groupId, long classNameId, java.lang.String layoutUuid,
5802                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5803                    throws com.liferay.portal.kernel.exception.SystemException,
5804                            com.liferay.portlet.journal.NoSuchArticleException {
5805                    return getPersistence()
5806                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
5807                            orderByComparator);
5808            }
5809    
5810            /**
5811            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5812            *
5813            * @param groupId the group ID
5814            * @param classNameId the class name ID
5815            * @param layoutUuid the layout uuid
5816            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5817            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5818            * @throws SystemException if a system exception occurred
5819            */
5820            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
5821                    long groupId, long classNameId, java.lang.String layoutUuid,
5822                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5823                    throws com.liferay.portal.kernel.exception.SystemException {
5824                    return getPersistence()
5825                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
5826                            orderByComparator);
5827            }
5828    
5829            /**
5830            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5831            *
5832            * @param id the primary key of the current journal article
5833            * @param groupId the group ID
5834            * @param classNameId the class name ID
5835            * @param layoutUuid the layout uuid
5836            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5837            * @return the previous, current, and next journal article
5838            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5839            * @throws SystemException if a system exception occurred
5840            */
5841            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
5842                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
5843                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5844                    throws com.liferay.portal.kernel.exception.SystemException,
5845                            com.liferay.portlet.journal.NoSuchArticleException {
5846                    return getPersistence()
5847                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
5848                            layoutUuid, orderByComparator);
5849            }
5850    
5851            /**
5852            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5853            *
5854            * @param groupId the group ID
5855            * @param classNameId the class name ID
5856            * @param layoutUuid the layout uuid
5857            * @return the matching journal articles that the user has permission to view
5858            * @throws SystemException if a system exception occurred
5859            */
5860            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
5861                    long groupId, long classNameId, java.lang.String layoutUuid)
5862                    throws com.liferay.portal.kernel.exception.SystemException {
5863                    return getPersistence()
5864                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
5865            }
5866    
5867            /**
5868            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5869            *
5870            * <p>
5871            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5872            * </p>
5873            *
5874            * @param groupId the group ID
5875            * @param classNameId the class name ID
5876            * @param layoutUuid the layout uuid
5877            * @param start the lower bound of the range of journal articles
5878            * @param end the upper bound of the range of journal articles (not inclusive)
5879            * @return the range of matching journal articles that the user has permission to view
5880            * @throws SystemException if a system exception occurred
5881            */
5882            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
5883                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5884                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5885                    return getPersistence()
5886                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
5887                            end);
5888            }
5889    
5890            /**
5891            * 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;.
5892            *
5893            * <p>
5894            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5895            * </p>
5896            *
5897            * @param groupId the group ID
5898            * @param classNameId the class name ID
5899            * @param layoutUuid the layout uuid
5900            * @param start the lower bound of the range of journal articles
5901            * @param end the upper bound of the range of journal articles (not inclusive)
5902            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5903            * @return the ordered range of matching journal articles that the user has permission to view
5904            * @throws SystemException if a system exception occurred
5905            */
5906            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
5907                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5908                    int end,
5909                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5910                    throws com.liferay.portal.kernel.exception.SystemException {
5911                    return getPersistence()
5912                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
5913                            end, orderByComparator);
5914            }
5915    
5916            /**
5917            * 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;.
5918            *
5919            * @param id the primary key of the current journal article
5920            * @param groupId the group ID
5921            * @param classNameId the class name ID
5922            * @param layoutUuid the layout uuid
5923            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5924            * @return the previous, current, and next journal article
5925            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5926            * @throws SystemException if a system exception occurred
5927            */
5928            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
5929                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
5930                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5931                    throws com.liferay.portal.kernel.exception.SystemException,
5932                            com.liferay.portlet.journal.NoSuchArticleException {
5933                    return getPersistence()
5934                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
5935                            layoutUuid, orderByComparator);
5936            }
5937    
5938            /**
5939            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
5940            *
5941            * @param groupId the group ID
5942            * @param classNameId the class name ID
5943            * @param layoutUuid the layout uuid
5944            * @throws SystemException if a system exception occurred
5945            */
5946            public static void removeByG_C_L(long groupId, long classNameId,
5947                    java.lang.String layoutUuid)
5948                    throws com.liferay.portal.kernel.exception.SystemException {
5949                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
5950            }
5951    
5952            /**
5953            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5954            *
5955            * @param groupId the group ID
5956            * @param classNameId the class name ID
5957            * @param layoutUuid the layout uuid
5958            * @return the number of matching journal articles
5959            * @throws SystemException if a system exception occurred
5960            */
5961            public static int countByG_C_L(long groupId, long classNameId,
5962                    java.lang.String layoutUuid)
5963                    throws com.liferay.portal.kernel.exception.SystemException {
5964                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
5965            }
5966    
5967            /**
5968            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5969            *
5970            * @param groupId the group ID
5971            * @param classNameId the class name ID
5972            * @param layoutUuid the layout uuid
5973            * @return the number of matching journal articles that the user has permission to view
5974            * @throws SystemException if a system exception occurred
5975            */
5976            public static int filterCountByG_C_L(long groupId, long classNameId,
5977                    java.lang.String layoutUuid)
5978                    throws com.liferay.portal.kernel.exception.SystemException {
5979                    return getPersistence()
5980                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
5981            }
5982    
5983            /**
5984            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5985            *
5986            * @param groupId the group ID
5987            * @param userId the user ID
5988            * @param classNameId the class name ID
5989            * @return the matching journal articles
5990            * @throws SystemException if a system exception occurred
5991            */
5992            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5993                    long groupId, long userId, long classNameId)
5994                    throws com.liferay.portal.kernel.exception.SystemException {
5995                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
5996            }
5997    
5998            /**
5999            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6000            *
6001            * <p>
6002            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6003            * </p>
6004            *
6005            * @param groupId the group ID
6006            * @param userId the user ID
6007            * @param classNameId the class name ID
6008            * @param start the lower bound of the range of journal articles
6009            * @param end the upper bound of the range of journal articles (not inclusive)
6010            * @return the range of matching journal articles
6011            * @throws SystemException if a system exception occurred
6012            */
6013            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6014                    long groupId, long userId, long classNameId, int start, int end)
6015                    throws com.liferay.portal.kernel.exception.SystemException {
6016                    return getPersistence()
6017                                       .findByG_U_C(groupId, userId, classNameId, start, end);
6018            }
6019    
6020            /**
6021            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6022            *
6023            * <p>
6024            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6025            * </p>
6026            *
6027            * @param groupId the group ID
6028            * @param userId the user ID
6029            * @param classNameId the class name ID
6030            * @param start the lower bound of the range of journal articles
6031            * @param end the upper bound of the range of journal articles (not inclusive)
6032            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6033            * @return the ordered range of matching journal articles
6034            * @throws SystemException if a system exception occurred
6035            */
6036            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6037                    long groupId, long userId, long classNameId, int start, int end,
6038                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6039                    throws com.liferay.portal.kernel.exception.SystemException {
6040                    return getPersistence()
6041                                       .findByG_U_C(groupId, userId, classNameId, start, end,
6042                            orderByComparator);
6043            }
6044    
6045            /**
6046            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6047            *
6048            * @param groupId the group ID
6049            * @param userId the user ID
6050            * @param classNameId the class name ID
6051            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6052            * @return the first matching journal article
6053            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6054            * @throws SystemException if a system exception occurred
6055            */
6056            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
6057                    long groupId, long userId, long classNameId,
6058                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6059                    throws com.liferay.portal.kernel.exception.SystemException,
6060                            com.liferay.portlet.journal.NoSuchArticleException {
6061                    return getPersistence()
6062                                       .findByG_U_C_First(groupId, userId, classNameId,
6063                            orderByComparator);
6064            }
6065    
6066            /**
6067            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6068            *
6069            * @param groupId the group ID
6070            * @param userId the user ID
6071            * @param classNameId the class name ID
6072            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6073            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6074            * @throws SystemException if a system exception occurred
6075            */
6076            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
6077                    long groupId, long userId, long classNameId,
6078                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6079                    throws com.liferay.portal.kernel.exception.SystemException {
6080                    return getPersistence()
6081                                       .fetchByG_U_C_First(groupId, userId, classNameId,
6082                            orderByComparator);
6083            }
6084    
6085            /**
6086            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6087            *
6088            * @param groupId the group ID
6089            * @param userId the user ID
6090            * @param classNameId the class name ID
6091            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6092            * @return the last matching journal article
6093            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6094            * @throws SystemException if a system exception occurred
6095            */
6096            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
6097                    long groupId, long userId, long classNameId,
6098                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6099                    throws com.liferay.portal.kernel.exception.SystemException,
6100                            com.liferay.portlet.journal.NoSuchArticleException {
6101                    return getPersistence()
6102                                       .findByG_U_C_Last(groupId, userId, classNameId,
6103                            orderByComparator);
6104            }
6105    
6106            /**
6107            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6108            *
6109            * @param groupId the group ID
6110            * @param userId the user ID
6111            * @param classNameId the class name ID
6112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6113            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6114            * @throws SystemException if a system exception occurred
6115            */
6116            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
6117                    long groupId, long userId, long classNameId,
6118                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6119                    throws com.liferay.portal.kernel.exception.SystemException {
6120                    return getPersistence()
6121                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
6122                            orderByComparator);
6123            }
6124    
6125            /**
6126            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6127            *
6128            * @param id the primary key of the current journal article
6129            * @param groupId the group ID
6130            * @param userId the user ID
6131            * @param classNameId the class name ID
6132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6133            * @return the previous, current, and next journal article
6134            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6135            * @throws SystemException if a system exception occurred
6136            */
6137            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
6138                    long id, long groupId, long userId, long classNameId,
6139                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6140                    throws com.liferay.portal.kernel.exception.SystemException,
6141                            com.liferay.portlet.journal.NoSuchArticleException {
6142                    return getPersistence()
6143                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
6144                            orderByComparator);
6145            }
6146    
6147            /**
6148            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6149            *
6150            * @param groupId the group ID
6151            * @param userId the user ID
6152            * @param classNameId the class name ID
6153            * @return the matching journal articles that the user has permission to view
6154            * @throws SystemException if a system exception occurred
6155            */
6156            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6157                    long groupId, long userId, long classNameId)
6158                    throws com.liferay.portal.kernel.exception.SystemException {
6159                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
6160            }
6161    
6162            /**
6163            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6164            *
6165            * <p>
6166            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6167            * </p>
6168            *
6169            * @param groupId the group ID
6170            * @param userId the user ID
6171            * @param classNameId the class name ID
6172            * @param start the lower bound of the range of journal articles
6173            * @param end the upper bound of the range of journal articles (not inclusive)
6174            * @return the range of matching journal articles that the user has permission to view
6175            * @throws SystemException if a system exception occurred
6176            */
6177            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6178                    long groupId, long userId, long classNameId, int start, int end)
6179                    throws com.liferay.portal.kernel.exception.SystemException {
6180                    return getPersistence()
6181                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
6182            }
6183    
6184            /**
6185            * 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;.
6186            *
6187            * <p>
6188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6189            * </p>
6190            *
6191            * @param groupId the group ID
6192            * @param userId the user ID
6193            * @param classNameId the class name ID
6194            * @param start the lower bound of the range of journal articles
6195            * @param end the upper bound of the range of journal articles (not inclusive)
6196            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6197            * @return the ordered range of matching journal articles that the user has permission to view
6198            * @throws SystemException if a system exception occurred
6199            */
6200            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6201                    long groupId, long userId, long classNameId, int start, int end,
6202                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6203                    throws com.liferay.portal.kernel.exception.SystemException {
6204                    return getPersistence()
6205                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
6206                            orderByComparator);
6207            }
6208    
6209            /**
6210            * 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;.
6211            *
6212            * @param id the primary key of the current journal article
6213            * @param groupId the group ID
6214            * @param userId the user ID
6215            * @param classNameId the class name ID
6216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6217            * @return the previous, current, and next journal article
6218            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6219            * @throws SystemException if a system exception occurred
6220            */
6221            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
6222                    long id, long groupId, long userId, long classNameId,
6223                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6224                    throws com.liferay.portal.kernel.exception.SystemException,
6225                            com.liferay.portlet.journal.NoSuchArticleException {
6226                    return getPersistence()
6227                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
6228                            classNameId, orderByComparator);
6229            }
6230    
6231            /**
6232            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
6233            *
6234            * @param groupId the group ID
6235            * @param userId the user ID
6236            * @param classNameId the class name ID
6237            * @throws SystemException if a system exception occurred
6238            */
6239            public static void removeByG_U_C(long groupId, long userId, long classNameId)
6240                    throws com.liferay.portal.kernel.exception.SystemException {
6241                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
6242            }
6243    
6244            /**
6245            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6246            *
6247            * @param groupId the group ID
6248            * @param userId the user ID
6249            * @param classNameId the class name ID
6250            * @return the number of matching journal articles
6251            * @throws SystemException if a system exception occurred
6252            */
6253            public static int countByG_U_C(long groupId, long userId, long classNameId)
6254                    throws com.liferay.portal.kernel.exception.SystemException {
6255                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
6256            }
6257    
6258            /**
6259            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6260            *
6261            * @param groupId the group ID
6262            * @param userId the user ID
6263            * @param classNameId the class name ID
6264            * @return the number of matching journal articles that the user has permission to view
6265            * @throws SystemException if a system exception occurred
6266            */
6267            public static int filterCountByG_U_C(long groupId, long userId,
6268                    long classNameId)
6269                    throws com.liferay.portal.kernel.exception.SystemException {
6270                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
6271            }
6272    
6273            /**
6274            * 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.
6275            *
6276            * @param groupId the group ID
6277            * @param articleId the article ID
6278            * @param version the version
6279            * @return the matching journal article
6280            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6281            * @throws SystemException if a system exception occurred
6282            */
6283            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
6284                    long groupId, java.lang.String articleId, double version)
6285                    throws com.liferay.portal.kernel.exception.SystemException,
6286                            com.liferay.portlet.journal.NoSuchArticleException {
6287                    return getPersistence().findByG_A_V(groupId, articleId, version);
6288            }
6289    
6290            /**
6291            * 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.
6292            *
6293            * @param groupId the group ID
6294            * @param articleId the article ID
6295            * @param version the version
6296            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6297            * @throws SystemException if a system exception occurred
6298            */
6299            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6300                    long groupId, java.lang.String articleId, double version)
6301                    throws com.liferay.portal.kernel.exception.SystemException {
6302                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
6303            }
6304    
6305            /**
6306            * 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.
6307            *
6308            * @param groupId the group ID
6309            * @param articleId the article ID
6310            * @param version the version
6311            * @param retrieveFromCache whether to use the finder cache
6312            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6313            * @throws SystemException if a system exception occurred
6314            */
6315            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6316                    long groupId, java.lang.String articleId, double version,
6317                    boolean retrieveFromCache)
6318                    throws com.liferay.portal.kernel.exception.SystemException {
6319                    return getPersistence()
6320                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
6321            }
6322    
6323            /**
6324            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
6325            *
6326            * @param groupId the group ID
6327            * @param articleId the article ID
6328            * @param version the version
6329            * @return the journal article that was removed
6330            * @throws SystemException if a system exception occurred
6331            */
6332            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
6333                    long groupId, java.lang.String articleId, double version)
6334                    throws com.liferay.portal.kernel.exception.SystemException,
6335                            com.liferay.portlet.journal.NoSuchArticleException {
6336                    return getPersistence().removeByG_A_V(groupId, articleId, version);
6337            }
6338    
6339            /**
6340            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
6341            *
6342            * @param groupId the group ID
6343            * @param articleId the article ID
6344            * @param version the version
6345            * @return the number of matching journal articles
6346            * @throws SystemException if a system exception occurred
6347            */
6348            public static int countByG_A_V(long groupId, java.lang.String articleId,
6349                    double version)
6350                    throws com.liferay.portal.kernel.exception.SystemException {
6351                    return getPersistence().countByG_A_V(groupId, articleId, version);
6352            }
6353    
6354            /**
6355            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6356            *
6357            * @param groupId the group ID
6358            * @param articleId the article ID
6359            * @param status the status
6360            * @return the matching journal articles
6361            * @throws SystemException if a system exception occurred
6362            */
6363            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6364                    long groupId, java.lang.String articleId, int status)
6365                    throws com.liferay.portal.kernel.exception.SystemException {
6366                    return getPersistence().findByG_A_ST(groupId, articleId, status);
6367            }
6368    
6369            /**
6370            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6371            *
6372            * <p>
6373            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6374            * </p>
6375            *
6376            * @param groupId the group ID
6377            * @param articleId the article ID
6378            * @param status the status
6379            * @param start the lower bound of the range of journal articles
6380            * @param end the upper bound of the range of journal articles (not inclusive)
6381            * @return the range of matching journal articles
6382            * @throws SystemException if a system exception occurred
6383            */
6384            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6385                    long groupId, java.lang.String articleId, int status, int start, int end)
6386                    throws com.liferay.portal.kernel.exception.SystemException {
6387                    return getPersistence()
6388                                       .findByG_A_ST(groupId, articleId, status, start, end);
6389            }
6390    
6391            /**
6392            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6393            *
6394            * <p>
6395            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6396            * </p>
6397            *
6398            * @param groupId the group ID
6399            * @param articleId the article ID
6400            * @param status the status
6401            * @param start the lower bound of the range of journal articles
6402            * @param end the upper bound of the range of journal articles (not inclusive)
6403            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6404            * @return the ordered range of matching journal articles
6405            * @throws SystemException if a system exception occurred
6406            */
6407            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6408                    long groupId, java.lang.String articleId, int status, int start,
6409                    int end,
6410                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6411                    throws com.liferay.portal.kernel.exception.SystemException {
6412                    return getPersistence()
6413                                       .findByG_A_ST(groupId, articleId, status, start, end,
6414                            orderByComparator);
6415            }
6416    
6417            /**
6418            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6419            *
6420            * @param groupId the group ID
6421            * @param articleId the article ID
6422            * @param status the status
6423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6424            * @return the first matching journal article
6425            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6426            * @throws SystemException if a system exception occurred
6427            */
6428            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
6429                    long groupId, java.lang.String articleId, int status,
6430                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6431                    throws com.liferay.portal.kernel.exception.SystemException,
6432                            com.liferay.portlet.journal.NoSuchArticleException {
6433                    return getPersistence()
6434                                       .findByG_A_ST_First(groupId, articleId, status,
6435                            orderByComparator);
6436            }
6437    
6438            /**
6439            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6440            *
6441            * @param groupId the group ID
6442            * @param articleId the article ID
6443            * @param status the status
6444            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6445            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6446            * @throws SystemException if a system exception occurred
6447            */
6448            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
6449                    long groupId, java.lang.String articleId, int status,
6450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6451                    throws com.liferay.portal.kernel.exception.SystemException {
6452                    return getPersistence()
6453                                       .fetchByG_A_ST_First(groupId, articleId, status,
6454                            orderByComparator);
6455            }
6456    
6457            /**
6458            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6459            *
6460            * @param groupId the group ID
6461            * @param articleId the article ID
6462            * @param status the status
6463            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6464            * @return the last matching journal article
6465            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6466            * @throws SystemException if a system exception occurred
6467            */
6468            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
6469                    long groupId, java.lang.String articleId, int status,
6470                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6471                    throws com.liferay.portal.kernel.exception.SystemException,
6472                            com.liferay.portlet.journal.NoSuchArticleException {
6473                    return getPersistence()
6474                                       .findByG_A_ST_Last(groupId, articleId, status,
6475                            orderByComparator);
6476            }
6477    
6478            /**
6479            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6480            *
6481            * @param groupId the group ID
6482            * @param articleId the article ID
6483            * @param status the status
6484            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6485            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6486            * @throws SystemException if a system exception occurred
6487            */
6488            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
6489                    long groupId, java.lang.String articleId, int status,
6490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6491                    throws com.liferay.portal.kernel.exception.SystemException {
6492                    return getPersistence()
6493                                       .fetchByG_A_ST_Last(groupId, articleId, status,
6494                            orderByComparator);
6495            }
6496    
6497            /**
6498            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6499            *
6500            * @param id the primary key of the current journal article
6501            * @param groupId the group ID
6502            * @param articleId the article ID
6503            * @param status the status
6504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6505            * @return the previous, current, and next journal article
6506            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6507            * @throws SystemException if a system exception occurred
6508            */
6509            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
6510                    long id, long groupId, java.lang.String articleId, int status,
6511                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6512                    throws com.liferay.portal.kernel.exception.SystemException,
6513                            com.liferay.portlet.journal.NoSuchArticleException {
6514                    return getPersistence()
6515                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
6516                            orderByComparator);
6517            }
6518    
6519            /**
6520            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6521            *
6522            * @param groupId the group ID
6523            * @param articleId the article ID
6524            * @param status the status
6525            * @return the matching journal articles that the user has permission to view
6526            * @throws SystemException if a system exception occurred
6527            */
6528            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6529                    long groupId, java.lang.String articleId, int status)
6530                    throws com.liferay.portal.kernel.exception.SystemException {
6531                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
6532            }
6533    
6534            /**
6535            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6536            *
6537            * <p>
6538            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6539            * </p>
6540            *
6541            * @param groupId the group ID
6542            * @param articleId the article ID
6543            * @param status the status
6544            * @param start the lower bound of the range of journal articles
6545            * @param end the upper bound of the range of journal articles (not inclusive)
6546            * @return the range of matching journal articles that the user has permission to view
6547            * @throws SystemException if a system exception occurred
6548            */
6549            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6550                    long groupId, java.lang.String articleId, int status, int start, int end)
6551                    throws com.liferay.portal.kernel.exception.SystemException {
6552                    return getPersistence()
6553                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
6554            }
6555    
6556            /**
6557            * 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;.
6558            *
6559            * <p>
6560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6561            * </p>
6562            *
6563            * @param groupId the group ID
6564            * @param articleId the article ID
6565            * @param status the status
6566            * @param start the lower bound of the range of journal articles
6567            * @param end the upper bound of the range of journal articles (not inclusive)
6568            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6569            * @return the ordered range of matching journal articles that the user has permission to view
6570            * @throws SystemException if a system exception occurred
6571            */
6572            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6573                    long groupId, java.lang.String articleId, int status, int start,
6574                    int end,
6575                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6576                    throws com.liferay.portal.kernel.exception.SystemException {
6577                    return getPersistence()
6578                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
6579                            orderByComparator);
6580            }
6581    
6582            /**
6583            * 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;.
6584            *
6585            * @param id the primary key of the current journal article
6586            * @param groupId the group ID
6587            * @param articleId the article ID
6588            * @param status the status
6589            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6590            * @return the previous, current, and next journal article
6591            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6592            * @throws SystemException if a system exception occurred
6593            */
6594            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
6595                    long id, long groupId, java.lang.String articleId, int status,
6596                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6597                    throws com.liferay.portal.kernel.exception.SystemException,
6598                            com.liferay.portlet.journal.NoSuchArticleException {
6599                    return getPersistence()
6600                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
6601                            status, orderByComparator);
6602            }
6603    
6604            /**
6605            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6606            *
6607            * @param groupId the group ID
6608            * @param articleId the article ID
6609            * @param statuses the statuses
6610            * @return the matching journal articles that the user has permission to view
6611            * @throws SystemException if a system exception occurred
6612            */
6613            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6614                    long groupId, java.lang.String articleId, int[] statuses)
6615                    throws com.liferay.portal.kernel.exception.SystemException {
6616                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
6617            }
6618    
6619            /**
6620            * 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;.
6621            *
6622            * <p>
6623            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6624            * </p>
6625            *
6626            * @param groupId the group ID
6627            * @param articleId the article ID
6628            * @param statuses the statuses
6629            * @param start the lower bound of the range of journal articles
6630            * @param end the upper bound of the range of journal articles (not inclusive)
6631            * @return the range of matching journal articles that the user has permission to view
6632            * @throws SystemException if a system exception occurred
6633            */
6634            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6635                    long groupId, java.lang.String articleId, int[] statuses, int start,
6636                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6637                    return getPersistence()
6638                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
6639            }
6640    
6641            /**
6642            * 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;.
6643            *
6644            * <p>
6645            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6646            * </p>
6647            *
6648            * @param groupId the group ID
6649            * @param articleId the article ID
6650            * @param statuses the statuses
6651            * @param start the lower bound of the range of journal articles
6652            * @param end the upper bound of the range of journal articles (not inclusive)
6653            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6654            * @return the ordered range of matching journal articles that the user has permission to view
6655            * @throws SystemException if a system exception occurred
6656            */
6657            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6658                    long groupId, java.lang.String articleId, int[] statuses, int start,
6659                    int end,
6660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6661                    throws com.liferay.portal.kernel.exception.SystemException {
6662                    return getPersistence()
6663                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
6664                            end, orderByComparator);
6665            }
6666    
6667            /**
6668            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6669            *
6670            * <p>
6671            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6672            * </p>
6673            *
6674            * @param groupId the group ID
6675            * @param articleId the article ID
6676            * @param statuses the statuses
6677            * @return the matching journal articles
6678            * @throws SystemException if a system exception occurred
6679            */
6680            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6681                    long groupId, java.lang.String articleId, int[] statuses)
6682                    throws com.liferay.portal.kernel.exception.SystemException {
6683                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
6684            }
6685    
6686            /**
6687            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6688            *
6689            * <p>
6690            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6691            * </p>
6692            *
6693            * @param groupId the group ID
6694            * @param articleId the article ID
6695            * @param statuses the statuses
6696            * @param start the lower bound of the range of journal articles
6697            * @param end the upper bound of the range of journal articles (not inclusive)
6698            * @return the range of matching journal articles
6699            * @throws SystemException if a system exception occurred
6700            */
6701            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6702                    long groupId, java.lang.String articleId, int[] statuses, int start,
6703                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6704                    return getPersistence()
6705                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
6706            }
6707    
6708            /**
6709            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6710            *
6711            * <p>
6712            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6713            * </p>
6714            *
6715            * @param groupId the group ID
6716            * @param articleId the article ID
6717            * @param statuses the statuses
6718            * @param start the lower bound of the range of journal articles
6719            * @param end the upper bound of the range of journal articles (not inclusive)
6720            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6721            * @return the ordered range of matching journal articles
6722            * @throws SystemException if a system exception occurred
6723            */
6724            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6725                    long groupId, java.lang.String articleId, int[] statuses, int start,
6726                    int end,
6727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6728                    throws com.liferay.portal.kernel.exception.SystemException {
6729                    return getPersistence()
6730                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
6731                            orderByComparator);
6732            }
6733    
6734            /**
6735            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
6736            *
6737            * @param groupId the group ID
6738            * @param articleId the article ID
6739            * @param status the status
6740            * @throws SystemException if a system exception occurred
6741            */
6742            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
6743                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6744                    getPersistence().removeByG_A_ST(groupId, articleId, status);
6745            }
6746    
6747            /**
6748            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6749            *
6750            * @param groupId the group ID
6751            * @param articleId the article ID
6752            * @param status the status
6753            * @return the number of matching journal articles
6754            * @throws SystemException if a system exception occurred
6755            */
6756            public static int countByG_A_ST(long groupId, java.lang.String articleId,
6757                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6758                    return getPersistence().countByG_A_ST(groupId, articleId, status);
6759            }
6760    
6761            /**
6762            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6763            *
6764            * @param groupId the group ID
6765            * @param articleId the article ID
6766            * @param statuses the statuses
6767            * @return the number of matching journal articles
6768            * @throws SystemException if a system exception occurred
6769            */
6770            public static int countByG_A_ST(long groupId, java.lang.String articleId,
6771                    int[] statuses)
6772                    throws com.liferay.portal.kernel.exception.SystemException {
6773                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
6774            }
6775    
6776            /**
6777            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6778            *
6779            * @param groupId the group ID
6780            * @param articleId the article ID
6781            * @param status the status
6782            * @return the number of matching journal articles that the user has permission to view
6783            * @throws SystemException if a system exception occurred
6784            */
6785            public static int filterCountByG_A_ST(long groupId,
6786                    java.lang.String articleId, int status)
6787                    throws com.liferay.portal.kernel.exception.SystemException {
6788                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
6789            }
6790    
6791            /**
6792            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6793            *
6794            * @param groupId the group ID
6795            * @param articleId the article ID
6796            * @param statuses the statuses
6797            * @return the number of matching journal articles that the user has permission to view
6798            * @throws SystemException if a system exception occurred
6799            */
6800            public static int filterCountByG_A_ST(long groupId,
6801                    java.lang.String articleId, int[] statuses)
6802                    throws com.liferay.portal.kernel.exception.SystemException {
6803                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
6804            }
6805    
6806            /**
6807            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6808            *
6809            * @param groupId the group ID
6810            * @param urlTitle the url title
6811            * @param status the status
6812            * @return the matching journal articles
6813            * @throws SystemException if a system exception occurred
6814            */
6815            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
6816                    long groupId, java.lang.String urlTitle, int status)
6817                    throws com.liferay.portal.kernel.exception.SystemException {
6818                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
6819            }
6820    
6821            /**
6822            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6823            *
6824            * <p>
6825            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6826            * </p>
6827            *
6828            * @param groupId the group ID
6829            * @param urlTitle the url title
6830            * @param status the status
6831            * @param start the lower bound of the range of journal articles
6832            * @param end the upper bound of the range of journal articles (not inclusive)
6833            * @return the range of matching journal articles
6834            * @throws SystemException if a system exception occurred
6835            */
6836            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
6837                    long groupId, java.lang.String urlTitle, int status, int start, int end)
6838                    throws com.liferay.portal.kernel.exception.SystemException {
6839                    return getPersistence()
6840                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
6841            }
6842    
6843            /**
6844            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6845            *
6846            * <p>
6847            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6848            * </p>
6849            *
6850            * @param groupId the group ID
6851            * @param urlTitle the url title
6852            * @param status the status
6853            * @param start the lower bound of the range of journal articles
6854            * @param end the upper bound of the range of journal articles (not inclusive)
6855            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6856            * @return the ordered range of matching journal articles
6857            * @throws SystemException if a system exception occurred
6858            */
6859            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
6860                    long groupId, java.lang.String urlTitle, int status, int start,
6861                    int end,
6862                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6863                    throws com.liferay.portal.kernel.exception.SystemException {
6864                    return getPersistence()
6865                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
6866                            orderByComparator);
6867            }
6868    
6869            /**
6870            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6871            *
6872            * @param groupId the group ID
6873            * @param urlTitle the url title
6874            * @param status the status
6875            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6876            * @return the first matching journal article
6877            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6878            * @throws SystemException if a system exception occurred
6879            */
6880            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
6881                    long groupId, java.lang.String urlTitle, int status,
6882                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6883                    throws com.liferay.portal.kernel.exception.SystemException,
6884                            com.liferay.portlet.journal.NoSuchArticleException {
6885                    return getPersistence()
6886                                       .findByG_UT_ST_First(groupId, urlTitle, status,
6887                            orderByComparator);
6888            }
6889    
6890            /**
6891            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6892            *
6893            * @param groupId the group ID
6894            * @param urlTitle the url title
6895            * @param status the status
6896            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6897            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6898            * @throws SystemException if a system exception occurred
6899            */
6900            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
6901                    long groupId, java.lang.String urlTitle, int status,
6902                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6903                    throws com.liferay.portal.kernel.exception.SystemException {
6904                    return getPersistence()
6905                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
6906                            orderByComparator);
6907            }
6908    
6909            /**
6910            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6911            *
6912            * @param groupId the group ID
6913            * @param urlTitle the url title
6914            * @param status the status
6915            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6916            * @return the last matching journal article
6917            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6918            * @throws SystemException if a system exception occurred
6919            */
6920            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
6921                    long groupId, java.lang.String urlTitle, int status,
6922                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6923                    throws com.liferay.portal.kernel.exception.SystemException,
6924                            com.liferay.portlet.journal.NoSuchArticleException {
6925                    return getPersistence()
6926                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
6927                            orderByComparator);
6928            }
6929    
6930            /**
6931            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6932            *
6933            * @param groupId the group ID
6934            * @param urlTitle the url title
6935            * @param status the status
6936            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6937            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6938            * @throws SystemException if a system exception occurred
6939            */
6940            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
6941                    long groupId, java.lang.String urlTitle, int status,
6942                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6943                    throws com.liferay.portal.kernel.exception.SystemException {
6944                    return getPersistence()
6945                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
6946                            orderByComparator);
6947            }
6948    
6949            /**
6950            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6951            *
6952            * @param id the primary key of the current journal article
6953            * @param groupId the group ID
6954            * @param urlTitle the url title
6955            * @param status the status
6956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6957            * @return the previous, current, and next journal article
6958            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6959            * @throws SystemException if a system exception occurred
6960            */
6961            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
6962                    long id, long groupId, java.lang.String urlTitle, int status,
6963                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6964                    throws com.liferay.portal.kernel.exception.SystemException,
6965                            com.liferay.portlet.journal.NoSuchArticleException {
6966                    return getPersistence()
6967                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
6968                            orderByComparator);
6969            }
6970    
6971            /**
6972            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6973            *
6974            * @param groupId the group ID
6975            * @param urlTitle the url title
6976            * @param status the status
6977            * @return the matching journal articles that the user has permission to view
6978            * @throws SystemException if a system exception occurred
6979            */
6980            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
6981                    long groupId, java.lang.String urlTitle, int status)
6982                    throws com.liferay.portal.kernel.exception.SystemException {
6983                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
6984            }
6985    
6986            /**
6987            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6988            *
6989            * <p>
6990            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6991            * </p>
6992            *
6993            * @param groupId the group ID
6994            * @param urlTitle the url title
6995            * @param status the status
6996            * @param start the lower bound of the range of journal articles
6997            * @param end the upper bound of the range of journal articles (not inclusive)
6998            * @return the range of matching journal articles that the user has permission to view
6999            * @throws SystemException if a system exception occurred
7000            */
7001            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7002                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7003                    throws com.liferay.portal.kernel.exception.SystemException {
7004                    return getPersistence()
7005                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7006            }
7007    
7008            /**
7009            * 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;.
7010            *
7011            * <p>
7012            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7013            * </p>
7014            *
7015            * @param groupId the group ID
7016            * @param urlTitle the url title
7017            * @param status the status
7018            * @param start the lower bound of the range of journal articles
7019            * @param end the upper bound of the range of journal articles (not inclusive)
7020            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7021            * @return the ordered range of matching journal articles that the user has permission to view
7022            * @throws SystemException if a system exception occurred
7023            */
7024            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7025                    long groupId, java.lang.String urlTitle, int status, int start,
7026                    int end,
7027                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7028                    throws com.liferay.portal.kernel.exception.SystemException {
7029                    return getPersistence()
7030                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7031                            orderByComparator);
7032            }
7033    
7034            /**
7035            * 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;.
7036            *
7037            * @param id the primary key of the current journal article
7038            * @param groupId the group ID
7039            * @param urlTitle the url title
7040            * @param status the status
7041            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7042            * @return the previous, current, and next journal article
7043            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7044            * @throws SystemException if a system exception occurred
7045            */
7046            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
7047                    long id, long groupId, java.lang.String urlTitle, int status,
7048                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7049                    throws com.liferay.portal.kernel.exception.SystemException,
7050                            com.liferay.portlet.journal.NoSuchArticleException {
7051                    return getPersistence()
7052                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7053                            status, orderByComparator);
7054            }
7055    
7056            /**
7057            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7058            *
7059            * @param groupId the group ID
7060            * @param urlTitle the url title
7061            * @param status the status
7062            * @throws SystemException if a system exception occurred
7063            */
7064            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7065                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7066                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7067            }
7068    
7069            /**
7070            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7071            *
7072            * @param groupId the group ID
7073            * @param urlTitle the url title
7074            * @param status the status
7075            * @return the number of matching journal articles
7076            * @throws SystemException if a system exception occurred
7077            */
7078            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7079                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7080                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7081            }
7082    
7083            /**
7084            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7085            *
7086            * @param groupId the group ID
7087            * @param urlTitle the url title
7088            * @param status the status
7089            * @return the number of matching journal articles that the user has permission to view
7090            * @throws SystemException if a system exception occurred
7091            */
7092            public static int filterCountByG_UT_ST(long groupId,
7093                    java.lang.String urlTitle, int status)
7094                    throws com.liferay.portal.kernel.exception.SystemException {
7095                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7096            }
7097    
7098            /**
7099            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7100            *
7101            * @param companyId the company ID
7102            * @param version the version
7103            * @param status the status
7104            * @return the matching journal articles
7105            * @throws SystemException if a system exception occurred
7106            */
7107            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7108                    long companyId, double version, int status)
7109                    throws com.liferay.portal.kernel.exception.SystemException {
7110                    return getPersistence().findByC_V_ST(companyId, version, status);
7111            }
7112    
7113            /**
7114            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7115            *
7116            * <p>
7117            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7118            * </p>
7119            *
7120            * @param companyId the company ID
7121            * @param version the version
7122            * @param status the status
7123            * @param start the lower bound of the range of journal articles
7124            * @param end the upper bound of the range of journal articles (not inclusive)
7125            * @return the range of matching journal articles
7126            * @throws SystemException if a system exception occurred
7127            */
7128            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7129                    long companyId, double version, int status, int start, int end)
7130                    throws com.liferay.portal.kernel.exception.SystemException {
7131                    return getPersistence()
7132                                       .findByC_V_ST(companyId, version, status, start, end);
7133            }
7134    
7135            /**
7136            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7137            *
7138            * <p>
7139            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7140            * </p>
7141            *
7142            * @param companyId the company ID
7143            * @param version the version
7144            * @param status the status
7145            * @param start the lower bound of the range of journal articles
7146            * @param end the upper bound of the range of journal articles (not inclusive)
7147            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7148            * @return the ordered range of matching journal articles
7149            * @throws SystemException if a system exception occurred
7150            */
7151            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7152                    long companyId, double version, int status, int start, int end,
7153                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7154                    throws com.liferay.portal.kernel.exception.SystemException {
7155                    return getPersistence()
7156                                       .findByC_V_ST(companyId, version, status, start, end,
7157                            orderByComparator);
7158            }
7159    
7160            /**
7161            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7162            *
7163            * @param companyId the company ID
7164            * @param version the version
7165            * @param status the status
7166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7167            * @return the first matching journal article
7168            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7169            * @throws SystemException if a system exception occurred
7170            */
7171            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
7172                    long companyId, double version, int status,
7173                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7174                    throws com.liferay.portal.kernel.exception.SystemException,
7175                            com.liferay.portlet.journal.NoSuchArticleException {
7176                    return getPersistence()
7177                                       .findByC_V_ST_First(companyId, version, status,
7178                            orderByComparator);
7179            }
7180    
7181            /**
7182            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7183            *
7184            * @param companyId the company ID
7185            * @param version the version
7186            * @param status the status
7187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7188            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7189            * @throws SystemException if a system exception occurred
7190            */
7191            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
7192                    long companyId, double version, int status,
7193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7194                    throws com.liferay.portal.kernel.exception.SystemException {
7195                    return getPersistence()
7196                                       .fetchByC_V_ST_First(companyId, version, status,
7197                            orderByComparator);
7198            }
7199    
7200            /**
7201            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7202            *
7203            * @param companyId the company ID
7204            * @param version the version
7205            * @param status the status
7206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7207            * @return the last matching journal article
7208            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7209            * @throws SystemException if a system exception occurred
7210            */
7211            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
7212                    long companyId, double version, int status,
7213                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7214                    throws com.liferay.portal.kernel.exception.SystemException,
7215                            com.liferay.portlet.journal.NoSuchArticleException {
7216                    return getPersistence()
7217                                       .findByC_V_ST_Last(companyId, version, status,
7218                            orderByComparator);
7219            }
7220    
7221            /**
7222            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7223            *
7224            * @param companyId the company ID
7225            * @param version the version
7226            * @param status the status
7227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7228            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7229            * @throws SystemException if a system exception occurred
7230            */
7231            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
7232                    long companyId, double version, int status,
7233                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7234                    throws com.liferay.portal.kernel.exception.SystemException {
7235                    return getPersistence()
7236                                       .fetchByC_V_ST_Last(companyId, version, status,
7237                            orderByComparator);
7238            }
7239    
7240            /**
7241            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7242            *
7243            * @param id the primary key of the current journal article
7244            * @param companyId the company ID
7245            * @param version the version
7246            * @param status the status
7247            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7248            * @return the previous, current, and next journal article
7249            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7250            * @throws SystemException if a system exception occurred
7251            */
7252            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
7253                    long id, long companyId, double version, int status,
7254                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7255                    throws com.liferay.portal.kernel.exception.SystemException,
7256                            com.liferay.portlet.journal.NoSuchArticleException {
7257                    return getPersistence()
7258                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7259                            orderByComparator);
7260            }
7261    
7262            /**
7263            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7264            *
7265            * @param companyId the company ID
7266            * @param version the version
7267            * @param status the status
7268            * @throws SystemException if a system exception occurred
7269            */
7270            public static void removeByC_V_ST(long companyId, double version, int status)
7271                    throws com.liferay.portal.kernel.exception.SystemException {
7272                    getPersistence().removeByC_V_ST(companyId, version, status);
7273            }
7274    
7275            /**
7276            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7277            *
7278            * @param companyId the company ID
7279            * @param version the version
7280            * @param status the status
7281            * @return the number of matching journal articles
7282            * @throws SystemException if a system exception occurred
7283            */
7284            public static int countByC_V_ST(long companyId, double version, int status)
7285                    throws com.liferay.portal.kernel.exception.SystemException {
7286                    return getPersistence().countByC_V_ST(companyId, version, status);
7287            }
7288    
7289            /**
7290            * Caches the journal article in the entity cache if it is enabled.
7291            *
7292            * @param journalArticle the journal article
7293            */
7294            public static void cacheResult(
7295                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7296                    getPersistence().cacheResult(journalArticle);
7297            }
7298    
7299            /**
7300            * Caches the journal articles in the entity cache if it is enabled.
7301            *
7302            * @param journalArticles the journal articles
7303            */
7304            public static void cacheResult(
7305                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
7306                    getPersistence().cacheResult(journalArticles);
7307            }
7308    
7309            /**
7310            * Creates a new journal article with the primary key. Does not add the journal article to the database.
7311            *
7312            * @param id the primary key for the new journal article
7313            * @return the new journal article
7314            */
7315            public static com.liferay.portlet.journal.model.JournalArticle create(
7316                    long id) {
7317                    return getPersistence().create(id);
7318            }
7319    
7320            /**
7321            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
7322            *
7323            * @param id the primary key of the journal article
7324            * @return the journal article that was removed
7325            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7326            * @throws SystemException if a system exception occurred
7327            */
7328            public static com.liferay.portlet.journal.model.JournalArticle remove(
7329                    long id)
7330                    throws com.liferay.portal.kernel.exception.SystemException,
7331                            com.liferay.portlet.journal.NoSuchArticleException {
7332                    return getPersistence().remove(id);
7333            }
7334    
7335            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
7336                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
7337                    throws com.liferay.portal.kernel.exception.SystemException {
7338                    return getPersistence().updateImpl(journalArticle);
7339            }
7340    
7341            /**
7342            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
7343            *
7344            * @param id the primary key of the journal article
7345            * @return the journal article
7346            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7347            * @throws SystemException if a system exception occurred
7348            */
7349            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
7350                    long id)
7351                    throws com.liferay.portal.kernel.exception.SystemException,
7352                            com.liferay.portlet.journal.NoSuchArticleException {
7353                    return getPersistence().findByPrimaryKey(id);
7354            }
7355    
7356            /**
7357            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
7358            *
7359            * @param id the primary key of the journal article
7360            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
7361            * @throws SystemException if a system exception occurred
7362            */
7363            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
7364                    long id) throws com.liferay.portal.kernel.exception.SystemException {
7365                    return getPersistence().fetchByPrimaryKey(id);
7366            }
7367    
7368            /**
7369            * Returns all the journal articles.
7370            *
7371            * @return the journal articles
7372            * @throws SystemException if a system exception occurred
7373            */
7374            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
7375                    throws com.liferay.portal.kernel.exception.SystemException {
7376                    return getPersistence().findAll();
7377            }
7378    
7379            /**
7380            * Returns a range of all the journal articles.
7381            *
7382            * <p>
7383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7384            * </p>
7385            *
7386            * @param start the lower bound of the range of journal articles
7387            * @param end the upper bound of the range of journal articles (not inclusive)
7388            * @return the range of journal articles
7389            * @throws SystemException if a system exception occurred
7390            */
7391            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7392                    int start, int end)
7393                    throws com.liferay.portal.kernel.exception.SystemException {
7394                    return getPersistence().findAll(start, end);
7395            }
7396    
7397            /**
7398            * Returns an ordered range of all the journal articles.
7399            *
7400            * <p>
7401            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7402            * </p>
7403            *
7404            * @param start the lower bound of the range of journal articles
7405            * @param end the upper bound of the range of journal articles (not inclusive)
7406            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7407            * @return the ordered range of journal articles
7408            * @throws SystemException if a system exception occurred
7409            */
7410            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7411                    int start, int end,
7412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7413                    throws com.liferay.portal.kernel.exception.SystemException {
7414                    return getPersistence().findAll(start, end, orderByComparator);
7415            }
7416    
7417            /**
7418            * Removes all the journal articles from the database.
7419            *
7420            * @throws SystemException if a system exception occurred
7421            */
7422            public static void removeAll()
7423                    throws com.liferay.portal.kernel.exception.SystemException {
7424                    getPersistence().removeAll();
7425            }
7426    
7427            /**
7428            * Returns the number of journal articles.
7429            *
7430            * @return the number of journal articles
7431            * @throws SystemException if a system exception occurred
7432            */
7433            public static int countAll()
7434                    throws com.liferay.portal.kernel.exception.SystemException {
7435                    return getPersistence().countAll();
7436            }
7437    
7438            public static JournalArticlePersistence getPersistence() {
7439                    if (_persistence == null) {
7440                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
7441    
7442                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
7443                                    "_persistence");
7444                    }
7445    
7446                    return _persistence;
7447            }
7448    
7449            /**
7450             * @deprecated
7451             */
7452            public void setPersistence(JournalArticlePersistence persistence) {
7453            }
7454    
7455            private static JournalArticlePersistence _persistence;
7456    }