001    /**
002     * Copyright (c) 2000-2013 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 static 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            * Returns all the journal articles where structureId = any &#63;.
1245            *
1246            * <p>
1247            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1248            * </p>
1249            *
1250            * @param structureIds the structure IDs
1251            * @return the matching journal articles
1252            * @throws SystemException if a system exception occurred
1253            */
1254            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1255                    java.lang.String[] structureIds)
1256                    throws com.liferay.portal.kernel.exception.SystemException {
1257                    return getPersistence().findByStructureId(structureIds);
1258            }
1259    
1260            /**
1261            * Returns a range of all the journal articles where structureId = any &#63;.
1262            *
1263            * <p>
1264            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1265            * </p>
1266            *
1267            * @param structureIds the structure IDs
1268            * @param start the lower bound of the range of journal articles
1269            * @param end the upper bound of the range of journal articles (not inclusive)
1270            * @return the range of matching journal articles
1271            * @throws SystemException if a system exception occurred
1272            */
1273            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1274                    java.lang.String[] structureIds, int start, int end)
1275                    throws com.liferay.portal.kernel.exception.SystemException {
1276                    return getPersistence().findByStructureId(structureIds, start, end);
1277            }
1278    
1279            /**
1280            * Returns an ordered range of all the journal articles where structureId = any &#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 structureIds the structure IDs
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            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1290            * @return the ordered range of matching journal articles
1291            * @throws SystemException if a system exception occurred
1292            */
1293            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1294                    java.lang.String[] structureIds, int start, int end,
1295                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1296                    throws com.liferay.portal.kernel.exception.SystemException {
1297                    return getPersistence()
1298                                       .findByStructureId(structureIds, start, end,
1299                            orderByComparator);
1300            }
1301    
1302            /**
1303            * Removes all the journal articles where structureId = &#63; from the database.
1304            *
1305            * @param structureId the structure ID
1306            * @throws SystemException if a system exception occurred
1307            */
1308            public static void removeByStructureId(java.lang.String structureId)
1309                    throws com.liferay.portal.kernel.exception.SystemException {
1310                    getPersistence().removeByStructureId(structureId);
1311            }
1312    
1313            /**
1314            * Returns the number of journal articles where structureId = &#63;.
1315            *
1316            * @param structureId the structure ID
1317            * @return the number of matching journal articles
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static int countByStructureId(java.lang.String structureId)
1321                    throws com.liferay.portal.kernel.exception.SystemException {
1322                    return getPersistence().countByStructureId(structureId);
1323            }
1324    
1325            /**
1326            * Returns the number of journal articles where structureId = any &#63;.
1327            *
1328            * @param structureIds the structure IDs
1329            * @return the number of matching journal articles
1330            * @throws SystemException if a system exception occurred
1331            */
1332            public static int countByStructureId(java.lang.String[] structureIds)
1333                    throws com.liferay.portal.kernel.exception.SystemException {
1334                    return getPersistence().countByStructureId(structureIds);
1335            }
1336    
1337            /**
1338            * Returns all the journal articles where templateId = &#63;.
1339            *
1340            * @param templateId the template ID
1341            * @return the matching journal articles
1342            * @throws SystemException if a system exception occurred
1343            */
1344            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1345                    java.lang.String templateId)
1346                    throws com.liferay.portal.kernel.exception.SystemException {
1347                    return getPersistence().findByTemplateId(templateId);
1348            }
1349    
1350            /**
1351            * Returns a range of all the journal articles where templateId = &#63;.
1352            *
1353            * <p>
1354            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.
1355            * </p>
1356            *
1357            * @param templateId the template ID
1358            * @param start the lower bound of the range of journal articles
1359            * @param end the upper bound of the range of journal articles (not inclusive)
1360            * @return the range of matching journal articles
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1364                    java.lang.String templateId, int start, int end)
1365                    throws com.liferay.portal.kernel.exception.SystemException {
1366                    return getPersistence().findByTemplateId(templateId, start, end);
1367            }
1368    
1369            /**
1370            * Returns an ordered range of all the journal articles where templateId = &#63;.
1371            *
1372            * <p>
1373            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1374            * </p>
1375            *
1376            * @param templateId the template ID
1377            * @param start the lower bound of the range of journal articles
1378            * @param end the upper bound of the range of journal articles (not inclusive)
1379            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1380            * @return the ordered range of matching journal articles
1381            * @throws SystemException if a system exception occurred
1382            */
1383            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1384                    java.lang.String templateId, int start, int end,
1385                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1386                    throws com.liferay.portal.kernel.exception.SystemException {
1387                    return getPersistence()
1388                                       .findByTemplateId(templateId, start, end, orderByComparator);
1389            }
1390    
1391            /**
1392            * Returns the first journal article in the ordered set where templateId = &#63;.
1393            *
1394            * @param templateId the template ID
1395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1396            * @return the first matching journal article
1397            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1398            * @throws SystemException if a system exception occurred
1399            */
1400            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1401                    java.lang.String templateId,
1402                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1403                    throws com.liferay.portal.kernel.exception.SystemException,
1404                            com.liferay.portlet.journal.NoSuchArticleException {
1405                    return getPersistence()
1406                                       .findByTemplateId_First(templateId, orderByComparator);
1407            }
1408    
1409            /**
1410            * Returns the first journal article in the ordered set where templateId = &#63;.
1411            *
1412            * @param templateId the template ID
1413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1414            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1415            * @throws SystemException if a system exception occurred
1416            */
1417            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1418                    java.lang.String templateId,
1419                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1420                    throws com.liferay.portal.kernel.exception.SystemException {
1421                    return getPersistence()
1422                                       .fetchByTemplateId_First(templateId, orderByComparator);
1423            }
1424    
1425            /**
1426            * Returns the last journal article in the ordered set where templateId = &#63;.
1427            *
1428            * @param templateId the template ID
1429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1430            * @return the last matching journal article
1431            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1432            * @throws SystemException if a system exception occurred
1433            */
1434            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1435                    java.lang.String templateId,
1436                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1437                    throws com.liferay.portal.kernel.exception.SystemException,
1438                            com.liferay.portlet.journal.NoSuchArticleException {
1439                    return getPersistence()
1440                                       .findByTemplateId_Last(templateId, orderByComparator);
1441            }
1442    
1443            /**
1444            * Returns the last journal article in the ordered set where templateId = &#63;.
1445            *
1446            * @param templateId the template ID
1447            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1448            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1449            * @throws SystemException if a system exception occurred
1450            */
1451            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1452                    java.lang.String templateId,
1453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1454                    throws com.liferay.portal.kernel.exception.SystemException {
1455                    return getPersistence()
1456                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1457            }
1458    
1459            /**
1460            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1461            *
1462            * @param id the primary key of the current journal article
1463            * @param templateId the template ID
1464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1465            * @return the previous, current, and next journal article
1466            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1467            * @throws SystemException if a system exception occurred
1468            */
1469            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1470                    long id, java.lang.String templateId,
1471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1472                    throws com.liferay.portal.kernel.exception.SystemException,
1473                            com.liferay.portlet.journal.NoSuchArticleException {
1474                    return getPersistence()
1475                                       .findByTemplateId_PrevAndNext(id, templateId,
1476                            orderByComparator);
1477            }
1478    
1479            /**
1480            * Removes all the journal articles where templateId = &#63; from the database.
1481            *
1482            * @param templateId the template ID
1483            * @throws SystemException if a system exception occurred
1484            */
1485            public static void removeByTemplateId(java.lang.String templateId)
1486                    throws com.liferay.portal.kernel.exception.SystemException {
1487                    getPersistence().removeByTemplateId(templateId);
1488            }
1489    
1490            /**
1491            * Returns the number of journal articles where templateId = &#63;.
1492            *
1493            * @param templateId the template ID
1494            * @return the number of matching journal articles
1495            * @throws SystemException if a system exception occurred
1496            */
1497            public static int countByTemplateId(java.lang.String templateId)
1498                    throws com.liferay.portal.kernel.exception.SystemException {
1499                    return getPersistence().countByTemplateId(templateId);
1500            }
1501    
1502            /**
1503            * Returns all the journal articles where layoutUuid = &#63;.
1504            *
1505            * @param layoutUuid the layout uuid
1506            * @return the matching journal articles
1507            * @throws SystemException if a system exception occurred
1508            */
1509            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1510                    java.lang.String layoutUuid)
1511                    throws com.liferay.portal.kernel.exception.SystemException {
1512                    return getPersistence().findByLayoutUuid(layoutUuid);
1513            }
1514    
1515            /**
1516            * Returns a range of all the journal articles where layoutUuid = &#63;.
1517            *
1518            * <p>
1519            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.
1520            * </p>
1521            *
1522            * @param layoutUuid the layout uuid
1523            * @param start the lower bound of the range of journal articles
1524            * @param end the upper bound of the range of journal articles (not inclusive)
1525            * @return the range of matching journal articles
1526            * @throws SystemException if a system exception occurred
1527            */
1528            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1529                    java.lang.String layoutUuid, int start, int end)
1530                    throws com.liferay.portal.kernel.exception.SystemException {
1531                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1532            }
1533    
1534            /**
1535            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1536            *
1537            * <p>
1538            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1539            * </p>
1540            *
1541            * @param layoutUuid the layout uuid
1542            * @param start the lower bound of the range of journal articles
1543            * @param end the upper bound of the range of journal articles (not inclusive)
1544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1545            * @return the ordered range of matching journal articles
1546            * @throws SystemException if a system exception occurred
1547            */
1548            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1549                    java.lang.String layoutUuid, int start, int end,
1550                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1551                    throws com.liferay.portal.kernel.exception.SystemException {
1552                    return getPersistence()
1553                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1554            }
1555    
1556            /**
1557            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1558            *
1559            * @param layoutUuid the layout uuid
1560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1561            * @return the first matching journal article
1562            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1563            * @throws SystemException if a system exception occurred
1564            */
1565            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First(
1566                    java.lang.String layoutUuid,
1567                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1568                    throws com.liferay.portal.kernel.exception.SystemException,
1569                            com.liferay.portlet.journal.NoSuchArticleException {
1570                    return getPersistence()
1571                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1572            }
1573    
1574            /**
1575            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1576            *
1577            * @param layoutUuid the layout uuid
1578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1579            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1580            * @throws SystemException if a system exception occurred
1581            */
1582            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First(
1583                    java.lang.String layoutUuid,
1584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1585                    throws com.liferay.portal.kernel.exception.SystemException {
1586                    return getPersistence()
1587                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1588            }
1589    
1590            /**
1591            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1592            *
1593            * @param layoutUuid the layout uuid
1594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1595            * @return the last matching journal article
1596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last(
1600                    java.lang.String layoutUuid,
1601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1602                    throws com.liferay.portal.kernel.exception.SystemException,
1603                            com.liferay.portlet.journal.NoSuchArticleException {
1604                    return getPersistence()
1605                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1606            }
1607    
1608            /**
1609            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1610            *
1611            * @param layoutUuid the layout uuid
1612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1613            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1614            * @throws SystemException if a system exception occurred
1615            */
1616            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last(
1617                    java.lang.String layoutUuid,
1618                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1619                    throws com.liferay.portal.kernel.exception.SystemException {
1620                    return getPersistence()
1621                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1622            }
1623    
1624            /**
1625            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1626            *
1627            * @param id the primary key of the current journal article
1628            * @param layoutUuid the layout uuid
1629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1630            * @return the previous, current, and next journal article
1631            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1632            * @throws SystemException if a system exception occurred
1633            */
1634            public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext(
1635                    long id, java.lang.String layoutUuid,
1636                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1637                    throws com.liferay.portal.kernel.exception.SystemException,
1638                            com.liferay.portlet.journal.NoSuchArticleException {
1639                    return getPersistence()
1640                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1641                            orderByComparator);
1642            }
1643    
1644            /**
1645            * Removes all the journal articles where layoutUuid = &#63; from the database.
1646            *
1647            * @param layoutUuid the layout uuid
1648            * @throws SystemException if a system exception occurred
1649            */
1650            public static void removeByLayoutUuid(java.lang.String layoutUuid)
1651                    throws com.liferay.portal.kernel.exception.SystemException {
1652                    getPersistence().removeByLayoutUuid(layoutUuid);
1653            }
1654    
1655            /**
1656            * Returns the number of journal articles where layoutUuid = &#63;.
1657            *
1658            * @param layoutUuid the layout uuid
1659            * @return the number of matching journal articles
1660            * @throws SystemException if a system exception occurred
1661            */
1662            public static int countByLayoutUuid(java.lang.String layoutUuid)
1663                    throws com.liferay.portal.kernel.exception.SystemException {
1664                    return getPersistence().countByLayoutUuid(layoutUuid);
1665            }
1666    
1667            /**
1668            * Returns all the journal articles where smallImageId = &#63;.
1669            *
1670            * @param smallImageId the small image ID
1671            * @return the matching journal articles
1672            * @throws SystemException if a system exception occurred
1673            */
1674            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1675                    long smallImageId)
1676                    throws com.liferay.portal.kernel.exception.SystemException {
1677                    return getPersistence().findBySmallImageId(smallImageId);
1678            }
1679    
1680            /**
1681            * Returns a range of all the journal articles where smallImageId = &#63;.
1682            *
1683            * <p>
1684            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1685            * </p>
1686            *
1687            * @param smallImageId the small image ID
1688            * @param start the lower bound of the range of journal articles
1689            * @param end the upper bound of the range of journal articles (not inclusive)
1690            * @return the range of matching journal articles
1691            * @throws SystemException if a system exception occurred
1692            */
1693            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1694                    long smallImageId, int start, int end)
1695                    throws com.liferay.portal.kernel.exception.SystemException {
1696                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1697            }
1698    
1699            /**
1700            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1701            *
1702            * <p>
1703            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1704            * </p>
1705            *
1706            * @param smallImageId the small image ID
1707            * @param start the lower bound of the range of journal articles
1708            * @param end the upper bound of the range of journal articles (not inclusive)
1709            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1710            * @return the ordered range of matching journal articles
1711            * @throws SystemException if a system exception occurred
1712            */
1713            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1714                    long smallImageId, int start, int end,
1715                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1716                    throws com.liferay.portal.kernel.exception.SystemException {
1717                    return getPersistence()
1718                                       .findBySmallImageId(smallImageId, start, end,
1719                            orderByComparator);
1720            }
1721    
1722            /**
1723            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1724            *
1725            * @param smallImageId the small image ID
1726            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1727            * @return the first matching journal article
1728            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1729            * @throws SystemException if a system exception occurred
1730            */
1731            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1732                    long smallImageId,
1733                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1734                    throws com.liferay.portal.kernel.exception.SystemException,
1735                            com.liferay.portlet.journal.NoSuchArticleException {
1736                    return getPersistence()
1737                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1738            }
1739    
1740            /**
1741            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1742            *
1743            * @param smallImageId the small image ID
1744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1745            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1746            * @throws SystemException if a system exception occurred
1747            */
1748            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1749                    long smallImageId,
1750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1751                    throws com.liferay.portal.kernel.exception.SystemException {
1752                    return getPersistence()
1753                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1754            }
1755    
1756            /**
1757            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1758            *
1759            * @param smallImageId the small image ID
1760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1761            * @return the last matching journal article
1762            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1763            * @throws SystemException if a system exception occurred
1764            */
1765            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1766                    long smallImageId,
1767                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1768                    throws com.liferay.portal.kernel.exception.SystemException,
1769                            com.liferay.portlet.journal.NoSuchArticleException {
1770                    return getPersistence()
1771                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1772            }
1773    
1774            /**
1775            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1776            *
1777            * @param smallImageId the small image ID
1778            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1779            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1780            * @throws SystemException if a system exception occurred
1781            */
1782            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1783                    long smallImageId,
1784                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1785                    throws com.liferay.portal.kernel.exception.SystemException {
1786                    return getPersistence()
1787                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1788            }
1789    
1790            /**
1791            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1792            *
1793            * @param id the primary key of the current journal article
1794            * @param smallImageId the small image ID
1795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1796            * @return the previous, current, and next journal article
1797            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1798            * @throws SystemException if a system exception occurred
1799            */
1800            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1801                    long id, long smallImageId,
1802                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1803                    throws com.liferay.portal.kernel.exception.SystemException,
1804                            com.liferay.portlet.journal.NoSuchArticleException {
1805                    return getPersistence()
1806                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1807                            orderByComparator);
1808            }
1809    
1810            /**
1811            * Removes all the journal articles where smallImageId = &#63; from the database.
1812            *
1813            * @param smallImageId the small image ID
1814            * @throws SystemException if a system exception occurred
1815            */
1816            public static void removeBySmallImageId(long smallImageId)
1817                    throws com.liferay.portal.kernel.exception.SystemException {
1818                    getPersistence().removeBySmallImageId(smallImageId);
1819            }
1820    
1821            /**
1822            * Returns the number of journal articles where smallImageId = &#63;.
1823            *
1824            * @param smallImageId the small image ID
1825            * @return the number of matching journal articles
1826            * @throws SystemException if a system exception occurred
1827            */
1828            public static int countBySmallImageId(long smallImageId)
1829                    throws com.liferay.portal.kernel.exception.SystemException {
1830                    return getPersistence().countBySmallImageId(smallImageId);
1831            }
1832    
1833            /**
1834            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1835            *
1836            * @param resourcePrimKey the resource prim key
1837            * @param status the status
1838            * @return the matching journal articles
1839            * @throws SystemException if a system exception occurred
1840            */
1841            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1842                    long resourcePrimKey, int status)
1843                    throws com.liferay.portal.kernel.exception.SystemException {
1844                    return getPersistence().findByR_ST(resourcePrimKey, status);
1845            }
1846    
1847            /**
1848            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1849            *
1850            * <p>
1851            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1852            * </p>
1853            *
1854            * @param resourcePrimKey the resource prim key
1855            * @param status the status
1856            * @param start the lower bound of the range of journal articles
1857            * @param end the upper bound of the range of journal articles (not inclusive)
1858            * @return the range of matching journal articles
1859            * @throws SystemException if a system exception occurred
1860            */
1861            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1862                    long resourcePrimKey, int status, int start, int end)
1863                    throws com.liferay.portal.kernel.exception.SystemException {
1864                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1865            }
1866    
1867            /**
1868            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1869            *
1870            * <p>
1871            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
1872            * </p>
1873            *
1874            * @param resourcePrimKey the resource prim key
1875            * @param status the status
1876            * @param start the lower bound of the range of journal articles
1877            * @param end the upper bound of the range of journal articles (not inclusive)
1878            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1879            * @return the ordered range of matching journal articles
1880            * @throws SystemException if a system exception occurred
1881            */
1882            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1883                    long resourcePrimKey, int status, int start, int end,
1884                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1885                    throws com.liferay.portal.kernel.exception.SystemException {
1886                    return getPersistence()
1887                                       .findByR_ST(resourcePrimKey, status, start, end,
1888                            orderByComparator);
1889            }
1890    
1891            /**
1892            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1893            *
1894            * @param resourcePrimKey the resource prim key
1895            * @param status the status
1896            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1897            * @return the first matching journal article
1898            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1899            * @throws SystemException if a system exception occurred
1900            */
1901            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1902                    long resourcePrimKey, int status,
1903                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1904                    throws com.liferay.portal.kernel.exception.SystemException,
1905                            com.liferay.portlet.journal.NoSuchArticleException {
1906                    return getPersistence()
1907                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1908            }
1909    
1910            /**
1911            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1912            *
1913            * @param resourcePrimKey the resource prim key
1914            * @param status the status
1915            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1916            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1917            * @throws SystemException if a system exception occurred
1918            */
1919            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
1920                    long resourcePrimKey, int status,
1921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1922                    throws com.liferay.portal.kernel.exception.SystemException {
1923                    return getPersistence()
1924                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
1925            }
1926    
1927            /**
1928            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1929            *
1930            * @param resourcePrimKey the resource prim key
1931            * @param status the status
1932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1933            * @return the last matching journal article
1934            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1935            * @throws SystemException if a system exception occurred
1936            */
1937            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1938                    long resourcePrimKey, int status,
1939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1940                    throws com.liferay.portal.kernel.exception.SystemException,
1941                            com.liferay.portlet.journal.NoSuchArticleException {
1942                    return getPersistence()
1943                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1944            }
1945    
1946            /**
1947            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1948            *
1949            * @param resourcePrimKey the resource prim key
1950            * @param status the status
1951            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1952            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1953            * @throws SystemException if a system exception occurred
1954            */
1955            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
1956                    long resourcePrimKey, int status,
1957                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1958                    throws com.liferay.portal.kernel.exception.SystemException {
1959                    return getPersistence()
1960                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
1961            }
1962    
1963            /**
1964            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1965            *
1966            * @param id the primary key of the current journal article
1967            * @param resourcePrimKey the resource prim key
1968            * @param status the status
1969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1970            * @return the previous, current, and next journal article
1971            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1972            * @throws SystemException if a system exception occurred
1973            */
1974            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1975                    long id, long resourcePrimKey, int status,
1976                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1977                    throws com.liferay.portal.kernel.exception.SystemException,
1978                            com.liferay.portlet.journal.NoSuchArticleException {
1979                    return getPersistence()
1980                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1981                            orderByComparator);
1982            }
1983    
1984            /**
1985            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
1986            *
1987            * @param resourcePrimKey the resource prim key
1988            * @param status the status
1989            * @throws SystemException if a system exception occurred
1990            */
1991            public static void removeByR_ST(long resourcePrimKey, int status)
1992                    throws com.liferay.portal.kernel.exception.SystemException {
1993                    getPersistence().removeByR_ST(resourcePrimKey, status);
1994            }
1995    
1996            /**
1997            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
1998            *
1999            * @param resourcePrimKey the resource prim key
2000            * @param status the status
2001            * @return the number of matching journal articles
2002            * @throws SystemException if a system exception occurred
2003            */
2004            public static int countByR_ST(long resourcePrimKey, int status)
2005                    throws com.liferay.portal.kernel.exception.SystemException {
2006                    return getPersistence().countByR_ST(resourcePrimKey, status);
2007            }
2008    
2009            /**
2010            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
2011            *
2012            * @param groupId the group ID
2013            * @param userId the user ID
2014            * @return the matching journal articles
2015            * @throws SystemException if a system exception occurred
2016            */
2017            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2018                    long groupId, long userId)
2019                    throws com.liferay.portal.kernel.exception.SystemException {
2020                    return getPersistence().findByG_U(groupId, userId);
2021            }
2022    
2023            /**
2024            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
2025            *
2026            * <p>
2027            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2028            * </p>
2029            *
2030            * @param groupId the group ID
2031            * @param userId the user ID
2032            * @param start the lower bound of the range of journal articles
2033            * @param end the upper bound of the range of journal articles (not inclusive)
2034            * @return the range of matching journal articles
2035            * @throws SystemException if a system exception occurred
2036            */
2037            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2038                    long groupId, long userId, int start, int end)
2039                    throws com.liferay.portal.kernel.exception.SystemException {
2040                    return getPersistence().findByG_U(groupId, userId, start, end);
2041            }
2042    
2043            /**
2044            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
2045            *
2046            * <p>
2047            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2048            * </p>
2049            *
2050            * @param groupId the group ID
2051            * @param userId the user ID
2052            * @param start the lower bound of the range of journal articles
2053            * @param end the upper bound of the range of journal articles (not inclusive)
2054            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2055            * @return the ordered range of matching journal articles
2056            * @throws SystemException if a system exception occurred
2057            */
2058            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2059                    long groupId, long userId, int start, int end,
2060                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2061                    throws com.liferay.portal.kernel.exception.SystemException {
2062                    return getPersistence()
2063                                       .findByG_U(groupId, userId, start, end, orderByComparator);
2064            }
2065    
2066            /**
2067            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2068            *
2069            * @param groupId the group ID
2070            * @param userId the user ID
2071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2072            * @return the first matching journal article
2073            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2074            * @throws SystemException if a system exception occurred
2075            */
2076            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First(
2077                    long groupId, long userId,
2078                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2079                    throws com.liferay.portal.kernel.exception.SystemException,
2080                            com.liferay.portlet.journal.NoSuchArticleException {
2081                    return getPersistence()
2082                                       .findByG_U_First(groupId, userId, orderByComparator);
2083            }
2084    
2085            /**
2086            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2087            *
2088            * @param groupId the group ID
2089            * @param userId the user ID
2090            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2091            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2092            * @throws SystemException if a system exception occurred
2093            */
2094            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First(
2095                    long groupId, long userId,
2096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2097                    throws com.liferay.portal.kernel.exception.SystemException {
2098                    return getPersistence()
2099                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2100            }
2101    
2102            /**
2103            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2104            *
2105            * @param groupId the group ID
2106            * @param userId the user ID
2107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2108            * @return the last matching journal article
2109            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2110            * @throws SystemException if a system exception occurred
2111            */
2112            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last(
2113                    long groupId, long userId,
2114                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2115                    throws com.liferay.portal.kernel.exception.SystemException,
2116                            com.liferay.portlet.journal.NoSuchArticleException {
2117                    return getPersistence()
2118                                       .findByG_U_Last(groupId, userId, orderByComparator);
2119            }
2120    
2121            /**
2122            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2123            *
2124            * @param groupId the group ID
2125            * @param userId the user ID
2126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2127            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2128            * @throws SystemException if a system exception occurred
2129            */
2130            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last(
2131                    long groupId, long userId,
2132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2133                    throws com.liferay.portal.kernel.exception.SystemException {
2134                    return getPersistence()
2135                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2140            *
2141            * @param id the primary key of the current journal article
2142            * @param groupId the group ID
2143            * @param userId the user ID
2144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2145            * @return the previous, current, and next journal article
2146            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2147            * @throws SystemException if a system exception occurred
2148            */
2149            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext(
2150                    long id, long groupId, long userId,
2151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2152                    throws com.liferay.portal.kernel.exception.SystemException,
2153                            com.liferay.portlet.journal.NoSuchArticleException {
2154                    return getPersistence()
2155                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2156            }
2157    
2158            /**
2159            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2160            *
2161            * @param groupId the group ID
2162            * @param userId the user ID
2163            * @return the matching journal articles that the user has permission to view
2164            * @throws SystemException if a system exception occurred
2165            */
2166            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2167                    long groupId, long userId)
2168                    throws com.liferay.portal.kernel.exception.SystemException {
2169                    return getPersistence().filterFindByG_U(groupId, userId);
2170            }
2171    
2172            /**
2173            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2174            *
2175            * <p>
2176            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.
2177            * </p>
2178            *
2179            * @param groupId the group ID
2180            * @param userId the user ID
2181            * @param start the lower bound of the range of journal articles
2182            * @param end the upper bound of the range of journal articles (not inclusive)
2183            * @return the range of matching journal articles that the user has permission to view
2184            * @throws SystemException if a system exception occurred
2185            */
2186            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2187                    long groupId, long userId, int start, int end)
2188                    throws com.liferay.portal.kernel.exception.SystemException {
2189                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2190            }
2191    
2192            /**
2193            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2194            *
2195            * <p>
2196            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2197            * </p>
2198            *
2199            * @param groupId the group ID
2200            * @param userId the user ID
2201            * @param start the lower bound of the range of journal articles
2202            * @param end the upper bound of the range of journal articles (not inclusive)
2203            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2204            * @return the ordered range of matching journal articles that the user has permission to view
2205            * @throws SystemException if a system exception occurred
2206            */
2207            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2208                    long groupId, long userId, int start, int end,
2209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2210                    throws com.liferay.portal.kernel.exception.SystemException {
2211                    return getPersistence()
2212                                       .filterFindByG_U(groupId, userId, start, end,
2213                            orderByComparator);
2214            }
2215    
2216            /**
2217            * 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;.
2218            *
2219            * @param id the primary key of the current journal article
2220            * @param groupId the group ID
2221            * @param userId the user ID
2222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2223            * @return the previous, current, and next journal article
2224            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2225            * @throws SystemException if a system exception occurred
2226            */
2227            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext(
2228                    long id, long groupId, long userId,
2229                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2230                    throws com.liferay.portal.kernel.exception.SystemException,
2231                            com.liferay.portlet.journal.NoSuchArticleException {
2232                    return getPersistence()
2233                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2234                            orderByComparator);
2235            }
2236    
2237            /**
2238            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2239            *
2240            * @param groupId the group ID
2241            * @param userId the user ID
2242            * @throws SystemException if a system exception occurred
2243            */
2244            public static void removeByG_U(long groupId, long userId)
2245                    throws com.liferay.portal.kernel.exception.SystemException {
2246                    getPersistence().removeByG_U(groupId, userId);
2247            }
2248    
2249            /**
2250            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2251            *
2252            * @param groupId the group ID
2253            * @param userId the user ID
2254            * @return the number of matching journal articles
2255            * @throws SystemException if a system exception occurred
2256            */
2257            public static int countByG_U(long groupId, long userId)
2258                    throws com.liferay.portal.kernel.exception.SystemException {
2259                    return getPersistence().countByG_U(groupId, userId);
2260            }
2261    
2262            /**
2263            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2264            *
2265            * @param groupId the group ID
2266            * @param userId the user ID
2267            * @return the number of matching journal articles that the user has permission to view
2268            * @throws SystemException if a system exception occurred
2269            */
2270            public static int filterCountByG_U(long groupId, long userId)
2271                    throws com.liferay.portal.kernel.exception.SystemException {
2272                    return getPersistence().filterCountByG_U(groupId, userId);
2273            }
2274    
2275            /**
2276            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2277            *
2278            * @param groupId the group ID
2279            * @param folderId the folder ID
2280            * @return the matching journal articles
2281            * @throws SystemException if a system exception occurred
2282            */
2283            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2284                    long groupId, long folderId)
2285                    throws com.liferay.portal.kernel.exception.SystemException {
2286                    return getPersistence().findByG_F(groupId, folderId);
2287            }
2288    
2289            /**
2290            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2291            *
2292            * <p>
2293            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2294            * </p>
2295            *
2296            * @param groupId the group ID
2297            * @param folderId the folder ID
2298            * @param start the lower bound of the range of journal articles
2299            * @param end the upper bound of the range of journal articles (not inclusive)
2300            * @return the range of matching journal articles
2301            * @throws SystemException if a system exception occurred
2302            */
2303            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2304                    long groupId, long folderId, int start, int end)
2305                    throws com.liferay.portal.kernel.exception.SystemException {
2306                    return getPersistence().findByG_F(groupId, folderId, start, end);
2307            }
2308    
2309            /**
2310            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2311            *
2312            * <p>
2313            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2314            * </p>
2315            *
2316            * @param groupId the group ID
2317            * @param folderId the folder ID
2318            * @param start the lower bound of the range of journal articles
2319            * @param end the upper bound of the range of journal articles (not inclusive)
2320            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2321            * @return the ordered range of matching journal articles
2322            * @throws SystemException if a system exception occurred
2323            */
2324            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2325                    long groupId, long folderId, int start, int end,
2326                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2327                    throws com.liferay.portal.kernel.exception.SystemException {
2328                    return getPersistence()
2329                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2330            }
2331    
2332            /**
2333            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2334            *
2335            * @param groupId the group ID
2336            * @param folderId the folder ID
2337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2338            * @return the first matching journal article
2339            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2340            * @throws SystemException if a system exception occurred
2341            */
2342            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First(
2343                    long groupId, long folderId,
2344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2345                    throws com.liferay.portal.kernel.exception.SystemException,
2346                            com.liferay.portlet.journal.NoSuchArticleException {
2347                    return getPersistence()
2348                                       .findByG_F_First(groupId, folderId, orderByComparator);
2349            }
2350    
2351            /**
2352            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2353            *
2354            * @param groupId the group ID
2355            * @param folderId the folder ID
2356            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2357            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2358            * @throws SystemException if a system exception occurred
2359            */
2360            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First(
2361                    long groupId, long folderId,
2362                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2363                    throws com.liferay.portal.kernel.exception.SystemException {
2364                    return getPersistence()
2365                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2366            }
2367    
2368            /**
2369            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2370            *
2371            * @param groupId the group ID
2372            * @param folderId the folder ID
2373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2374            * @return the last matching journal article
2375            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2376            * @throws SystemException if a system exception occurred
2377            */
2378            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last(
2379                    long groupId, long folderId,
2380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2381                    throws com.liferay.portal.kernel.exception.SystemException,
2382                            com.liferay.portlet.journal.NoSuchArticleException {
2383                    return getPersistence()
2384                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2385            }
2386    
2387            /**
2388            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2389            *
2390            * @param groupId the group ID
2391            * @param folderId the folder ID
2392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2393            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2394            * @throws SystemException if a system exception occurred
2395            */
2396            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last(
2397                    long groupId, long folderId,
2398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2399                    throws com.liferay.portal.kernel.exception.SystemException {
2400                    return getPersistence()
2401                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2402            }
2403    
2404            /**
2405            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2406            *
2407            * @param id the primary key of the current journal article
2408            * @param groupId the group ID
2409            * @param folderId the folder ID
2410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2411            * @return the previous, current, and next journal article
2412            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2413            * @throws SystemException if a system exception occurred
2414            */
2415            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext(
2416                    long id, long groupId, long folderId,
2417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2418                    throws com.liferay.portal.kernel.exception.SystemException,
2419                            com.liferay.portlet.journal.NoSuchArticleException {
2420                    return getPersistence()
2421                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2422                            orderByComparator);
2423            }
2424    
2425            /**
2426            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2427            *
2428            * @param groupId the group ID
2429            * @param folderId the folder ID
2430            * @return the matching journal articles that the user has permission to view
2431            * @throws SystemException if a system exception occurred
2432            */
2433            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2434                    long groupId, long folderId)
2435                    throws com.liferay.portal.kernel.exception.SystemException {
2436                    return getPersistence().filterFindByG_F(groupId, folderId);
2437            }
2438    
2439            /**
2440            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2441            *
2442            * <p>
2443            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2444            * </p>
2445            *
2446            * @param groupId the group ID
2447            * @param folderId the folder ID
2448            * @param start the lower bound of the range of journal articles
2449            * @param end the upper bound of the range of journal articles (not inclusive)
2450            * @return the range of matching journal articles that the user has permission to view
2451            * @throws SystemException if a system exception occurred
2452            */
2453            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2454                    long groupId, long folderId, int start, int end)
2455                    throws com.liferay.portal.kernel.exception.SystemException {
2456                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2457            }
2458    
2459            /**
2460            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2461            *
2462            * <p>
2463            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2464            * </p>
2465            *
2466            * @param groupId the group ID
2467            * @param folderId the folder ID
2468            * @param start the lower bound of the range of journal articles
2469            * @param end the upper bound of the range of journal articles (not inclusive)
2470            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2471            * @return the ordered range of matching journal articles that the user has permission to view
2472            * @throws SystemException if a system exception occurred
2473            */
2474            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2475                    long groupId, long folderId, int start, int end,
2476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2477                    throws com.liferay.portal.kernel.exception.SystemException {
2478                    return getPersistence()
2479                                       .filterFindByG_F(groupId, folderId, start, end,
2480                            orderByComparator);
2481            }
2482    
2483            /**
2484            * 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;.
2485            *
2486            * @param id the primary key of the current journal article
2487            * @param groupId the group ID
2488            * @param folderId the folder ID
2489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2490            * @return the previous, current, and next journal article
2491            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2492            * @throws SystemException if a system exception occurred
2493            */
2494            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext(
2495                    long id, long groupId, long folderId,
2496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2497                    throws com.liferay.portal.kernel.exception.SystemException,
2498                            com.liferay.portlet.journal.NoSuchArticleException {
2499                    return getPersistence()
2500                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2501                            orderByComparator);
2502            }
2503    
2504            /**
2505            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2506            *
2507            * @param groupId the group ID
2508            * @param folderIds the folder IDs
2509            * @return the matching journal articles that the user has permission to view
2510            * @throws SystemException if a system exception occurred
2511            */
2512            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2513                    long groupId, long[] folderIds)
2514                    throws com.liferay.portal.kernel.exception.SystemException {
2515                    return getPersistence().filterFindByG_F(groupId, folderIds);
2516            }
2517    
2518            /**
2519            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2520            *
2521            * <p>
2522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2523            * </p>
2524            *
2525            * @param groupId the group ID
2526            * @param folderIds the folder IDs
2527            * @param start the lower bound of the range of journal articles
2528            * @param end the upper bound of the range of journal articles (not inclusive)
2529            * @return the range of matching journal articles that the user has permission to view
2530            * @throws SystemException if a system exception occurred
2531            */
2532            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2533                    long groupId, long[] folderIds, int start, int end)
2534                    throws com.liferay.portal.kernel.exception.SystemException {
2535                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2536            }
2537    
2538            /**
2539            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2540            *
2541            * <p>
2542            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2543            * </p>
2544            *
2545            * @param groupId the group ID
2546            * @param folderIds the folder IDs
2547            * @param start the lower bound of the range of journal articles
2548            * @param end the upper bound of the range of journal articles (not inclusive)
2549            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2550            * @return the ordered range of matching journal articles that the user has permission to view
2551            * @throws SystemException if a system exception occurred
2552            */
2553            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2554                    long groupId, long[] folderIds, int start, int end,
2555                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2556                    throws com.liferay.portal.kernel.exception.SystemException {
2557                    return getPersistence()
2558                                       .filterFindByG_F(groupId, folderIds, start, end,
2559                            orderByComparator);
2560            }
2561    
2562            /**
2563            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2564            *
2565            * <p>
2566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2567            * </p>
2568            *
2569            * @param groupId the group ID
2570            * @param folderIds the folder IDs
2571            * @return the matching journal articles
2572            * @throws SystemException if a system exception occurred
2573            */
2574            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2575                    long groupId, long[] folderIds)
2576                    throws com.liferay.portal.kernel.exception.SystemException {
2577                    return getPersistence().findByG_F(groupId, folderIds);
2578            }
2579    
2580            /**
2581            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2582            *
2583            * <p>
2584            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2585            * </p>
2586            *
2587            * @param groupId the group ID
2588            * @param folderIds the folder IDs
2589            * @param start the lower bound of the range of journal articles
2590            * @param end the upper bound of the range of journal articles (not inclusive)
2591            * @return the range of matching journal articles
2592            * @throws SystemException if a system exception occurred
2593            */
2594            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2595                    long groupId, long[] folderIds, int start, int end)
2596                    throws com.liferay.portal.kernel.exception.SystemException {
2597                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2598            }
2599    
2600            /**
2601            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2602            *
2603            * <p>
2604            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2605            * </p>
2606            *
2607            * @param groupId the group ID
2608            * @param folderIds the folder IDs
2609            * @param start the lower bound of the range of journal articles
2610            * @param end the upper bound of the range of journal articles (not inclusive)
2611            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2612            * @return the ordered range of matching journal articles
2613            * @throws SystemException if a system exception occurred
2614            */
2615            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2616                    long groupId, long[] folderIds, int start, int end,
2617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2618                    throws com.liferay.portal.kernel.exception.SystemException {
2619                    return getPersistence()
2620                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2621            }
2622    
2623            /**
2624            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2625            *
2626            * @param groupId the group ID
2627            * @param folderId the folder ID
2628            * @throws SystemException if a system exception occurred
2629            */
2630            public static void removeByG_F(long groupId, long folderId)
2631                    throws com.liferay.portal.kernel.exception.SystemException {
2632                    getPersistence().removeByG_F(groupId, folderId);
2633            }
2634    
2635            /**
2636            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2637            *
2638            * @param groupId the group ID
2639            * @param folderId the folder ID
2640            * @return the number of matching journal articles
2641            * @throws SystemException if a system exception occurred
2642            */
2643            public static int countByG_F(long groupId, long folderId)
2644                    throws com.liferay.portal.kernel.exception.SystemException {
2645                    return getPersistence().countByG_F(groupId, folderId);
2646            }
2647    
2648            /**
2649            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2650            *
2651            * @param groupId the group ID
2652            * @param folderIds the folder IDs
2653            * @return the number of matching journal articles
2654            * @throws SystemException if a system exception occurred
2655            */
2656            public static int countByG_F(long groupId, long[] folderIds)
2657                    throws com.liferay.portal.kernel.exception.SystemException {
2658                    return getPersistence().countByG_F(groupId, folderIds);
2659            }
2660    
2661            /**
2662            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2663            *
2664            * @param groupId the group ID
2665            * @param folderId the folder ID
2666            * @return the number of matching journal articles that the user has permission to view
2667            * @throws SystemException if a system exception occurred
2668            */
2669            public static int filterCountByG_F(long groupId, long folderId)
2670                    throws com.liferay.portal.kernel.exception.SystemException {
2671                    return getPersistence().filterCountByG_F(groupId, folderId);
2672            }
2673    
2674            /**
2675            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2676            *
2677            * @param groupId the group ID
2678            * @param folderIds the folder IDs
2679            * @return the number of matching journal articles that the user has permission to view
2680            * @throws SystemException if a system exception occurred
2681            */
2682            public static int filterCountByG_F(long groupId, long[] folderIds)
2683                    throws com.liferay.portal.kernel.exception.SystemException {
2684                    return getPersistence().filterCountByG_F(groupId, folderIds);
2685            }
2686    
2687            /**
2688            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2689            *
2690            * @param groupId the group ID
2691            * @param articleId the article ID
2692            * @return the matching journal articles
2693            * @throws SystemException if a system exception occurred
2694            */
2695            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2696                    long groupId, java.lang.String articleId)
2697                    throws com.liferay.portal.kernel.exception.SystemException {
2698                    return getPersistence().findByG_A(groupId, articleId);
2699            }
2700    
2701            /**
2702            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2703            *
2704            * <p>
2705            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2706            * </p>
2707            *
2708            * @param groupId the group ID
2709            * @param articleId the article ID
2710            * @param start the lower bound of the range of journal articles
2711            * @param end the upper bound of the range of journal articles (not inclusive)
2712            * @return the range of matching journal articles
2713            * @throws SystemException if a system exception occurred
2714            */
2715            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2716                    long groupId, java.lang.String articleId, int start, int end)
2717                    throws com.liferay.portal.kernel.exception.SystemException {
2718                    return getPersistence().findByG_A(groupId, articleId, start, end);
2719            }
2720    
2721            /**
2722            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2723            *
2724            * <p>
2725            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2726            * </p>
2727            *
2728            * @param groupId the group ID
2729            * @param articleId the article ID
2730            * @param start the lower bound of the range of journal articles
2731            * @param end the upper bound of the range of journal articles (not inclusive)
2732            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2733            * @return the ordered range of matching journal articles
2734            * @throws SystemException if a system exception occurred
2735            */
2736            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2737                    long groupId, java.lang.String articleId, int start, int end,
2738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2739                    throws com.liferay.portal.kernel.exception.SystemException {
2740                    return getPersistence()
2741                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2742            }
2743    
2744            /**
2745            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2746            *
2747            * @param groupId the group ID
2748            * @param articleId the article ID
2749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2750            * @return the first matching journal article
2751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2752            * @throws SystemException if a system exception occurred
2753            */
2754            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
2755                    long groupId, java.lang.String articleId,
2756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2757                    throws com.liferay.portal.kernel.exception.SystemException,
2758                            com.liferay.portlet.journal.NoSuchArticleException {
2759                    return getPersistence()
2760                                       .findByG_A_First(groupId, articleId, orderByComparator);
2761            }
2762    
2763            /**
2764            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2765            *
2766            * @param groupId the group ID
2767            * @param articleId the article ID
2768            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2769            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2770            * @throws SystemException if a system exception occurred
2771            */
2772            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First(
2773                    long groupId, java.lang.String articleId,
2774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2775                    throws com.liferay.portal.kernel.exception.SystemException {
2776                    return getPersistence()
2777                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
2778            }
2779    
2780            /**
2781            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2782            *
2783            * @param groupId the group ID
2784            * @param articleId the article ID
2785            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2786            * @return the last matching journal article
2787            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2788            * @throws SystemException if a system exception occurred
2789            */
2790            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
2791                    long groupId, java.lang.String articleId,
2792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2793                    throws com.liferay.portal.kernel.exception.SystemException,
2794                            com.liferay.portlet.journal.NoSuchArticleException {
2795                    return getPersistence()
2796                                       .findByG_A_Last(groupId, articleId, orderByComparator);
2797            }
2798    
2799            /**
2800            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2801            *
2802            * @param groupId the group ID
2803            * @param articleId the article ID
2804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2805            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2806            * @throws SystemException if a system exception occurred
2807            */
2808            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
2809                    long groupId, java.lang.String articleId,
2810                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2811                    throws com.liferay.portal.kernel.exception.SystemException {
2812                    return getPersistence()
2813                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
2814            }
2815    
2816            /**
2817            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2818            *
2819            * @param id the primary key of the current journal article
2820            * @param groupId the group ID
2821            * @param articleId the article ID
2822            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2823            * @return the previous, current, and next journal article
2824            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2825            * @throws SystemException if a system exception occurred
2826            */
2827            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
2828                    long id, long groupId, java.lang.String articleId,
2829                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2830                    throws com.liferay.portal.kernel.exception.SystemException,
2831                            com.liferay.portlet.journal.NoSuchArticleException {
2832                    return getPersistence()
2833                                       .findByG_A_PrevAndNext(id, groupId, articleId,
2834                            orderByComparator);
2835            }
2836    
2837            /**
2838            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2839            *
2840            * @param groupId the group ID
2841            * @param articleId the article ID
2842            * @return the matching journal articles that the user has permission to view
2843            * @throws SystemException if a system exception occurred
2844            */
2845            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2846                    long groupId, java.lang.String articleId)
2847                    throws com.liferay.portal.kernel.exception.SystemException {
2848                    return getPersistence().filterFindByG_A(groupId, articleId);
2849            }
2850    
2851            /**
2852            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2853            *
2854            * <p>
2855            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2856            * </p>
2857            *
2858            * @param groupId the group ID
2859            * @param articleId the article ID
2860            * @param start the lower bound of the range of journal articles
2861            * @param end the upper bound of the range of journal articles (not inclusive)
2862            * @return the range of matching journal articles that the user has permission to view
2863            * @throws SystemException if a system exception occurred
2864            */
2865            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2866                    long groupId, java.lang.String articleId, int start, int end)
2867                    throws com.liferay.portal.kernel.exception.SystemException {
2868                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
2869            }
2870    
2871            /**
2872            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
2873            *
2874            * <p>
2875            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2876            * </p>
2877            *
2878            * @param groupId the group ID
2879            * @param articleId the article ID
2880            * @param start the lower bound of the range of journal articles
2881            * @param end the upper bound of the range of journal articles (not inclusive)
2882            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2883            * @return the ordered range of matching journal articles that the user has permission to view
2884            * @throws SystemException if a system exception occurred
2885            */
2886            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2887                    long groupId, java.lang.String articleId, int start, int end,
2888                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2889                    throws com.liferay.portal.kernel.exception.SystemException {
2890                    return getPersistence()
2891                                       .filterFindByG_A(groupId, articleId, start, end,
2892                            orderByComparator);
2893            }
2894    
2895            /**
2896            * 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;.
2897            *
2898            * @param id the primary key of the current journal article
2899            * @param groupId the group ID
2900            * @param articleId the article ID
2901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2902            * @return the previous, current, and next journal article
2903            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2904            * @throws SystemException if a system exception occurred
2905            */
2906            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
2907                    long id, long groupId, java.lang.String articleId,
2908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2909                    throws com.liferay.portal.kernel.exception.SystemException,
2910                            com.liferay.portlet.journal.NoSuchArticleException {
2911                    return getPersistence()
2912                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
2913                            orderByComparator);
2914            }
2915    
2916            /**
2917            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2918            *
2919            * @param groupId the group ID
2920            * @param articleId the article ID
2921            * @throws SystemException if a system exception occurred
2922            */
2923            public static void removeByG_A(long groupId, java.lang.String articleId)
2924                    throws com.liferay.portal.kernel.exception.SystemException {
2925                    getPersistence().removeByG_A(groupId, articleId);
2926            }
2927    
2928            /**
2929            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
2930            *
2931            * @param groupId the group ID
2932            * @param articleId the article ID
2933            * @return the number of matching journal articles
2934            * @throws SystemException if a system exception occurred
2935            */
2936            public static int countByG_A(long groupId, java.lang.String articleId)
2937                    throws com.liferay.portal.kernel.exception.SystemException {
2938                    return getPersistence().countByG_A(groupId, articleId);
2939            }
2940    
2941            /**
2942            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2943            *
2944            * @param groupId the group ID
2945            * @param articleId the article ID
2946            * @return the number of matching journal articles that the user has permission to view
2947            * @throws SystemException if a system exception occurred
2948            */
2949            public static int filterCountByG_A(long groupId, java.lang.String articleId)
2950                    throws com.liferay.portal.kernel.exception.SystemException {
2951                    return getPersistence().filterCountByG_A(groupId, articleId);
2952            }
2953    
2954            /**
2955            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
2956            *
2957            * @param groupId the group ID
2958            * @param urlTitle the url title
2959            * @return the matching journal articles
2960            * @throws SystemException if a system exception occurred
2961            */
2962            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2963                    long groupId, java.lang.String urlTitle)
2964                    throws com.liferay.portal.kernel.exception.SystemException {
2965                    return getPersistence().findByG_UT(groupId, urlTitle);
2966            }
2967    
2968            /**
2969            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2970            *
2971            * <p>
2972            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
2973            * </p>
2974            *
2975            * @param groupId the group ID
2976            * @param urlTitle the url title
2977            * @param start the lower bound of the range of journal articles
2978            * @param end the upper bound of the range of journal articles (not inclusive)
2979            * @return the range of matching journal articles
2980            * @throws SystemException if a system exception occurred
2981            */
2982            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2983                    long groupId, java.lang.String urlTitle, int start, int end)
2984                    throws com.liferay.portal.kernel.exception.SystemException {
2985                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
2986            }
2987    
2988            /**
2989            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2990            *
2991            * <p>
2992            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.
2993            * </p>
2994            *
2995            * @param groupId the group ID
2996            * @param urlTitle the url title
2997            * @param start the lower bound of the range of journal articles
2998            * @param end the upper bound of the range of journal articles (not inclusive)
2999            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3000            * @return the ordered range of matching journal articles
3001            * @throws SystemException if a system exception occurred
3002            */
3003            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3004                    long groupId, java.lang.String urlTitle, int start, int end,
3005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3006                    throws com.liferay.portal.kernel.exception.SystemException {
3007                    return getPersistence()
3008                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
3009            }
3010    
3011            /**
3012            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3013            *
3014            * @param groupId the group ID
3015            * @param urlTitle the url title
3016            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3017            * @return the first matching journal article
3018            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3019            * @throws SystemException if a system exception occurred
3020            */
3021            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
3022                    long groupId, java.lang.String urlTitle,
3023                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3024                    throws com.liferay.portal.kernel.exception.SystemException,
3025                            com.liferay.portlet.journal.NoSuchArticleException {
3026                    return getPersistence()
3027                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
3028            }
3029    
3030            /**
3031            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3032            *
3033            * @param groupId the group ID
3034            * @param urlTitle the url title
3035            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3036            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3037            * @throws SystemException if a system exception occurred
3038            */
3039            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
3040                    long groupId, java.lang.String urlTitle,
3041                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3042                    throws com.liferay.portal.kernel.exception.SystemException {
3043                    return getPersistence()
3044                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
3045            }
3046    
3047            /**
3048            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3049            *
3050            * @param groupId the group ID
3051            * @param urlTitle the url title
3052            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3053            * @return the last matching journal article
3054            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3055            * @throws SystemException if a system exception occurred
3056            */
3057            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
3058                    long groupId, java.lang.String urlTitle,
3059                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3060                    throws com.liferay.portal.kernel.exception.SystemException,
3061                            com.liferay.portlet.journal.NoSuchArticleException {
3062                    return getPersistence()
3063                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
3064            }
3065    
3066            /**
3067            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3068            *
3069            * @param groupId the group ID
3070            * @param urlTitle the url title
3071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3072            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3073            * @throws SystemException if a system exception occurred
3074            */
3075            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
3076                    long groupId, java.lang.String urlTitle,
3077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3078                    throws com.liferay.portal.kernel.exception.SystemException {
3079                    return getPersistence()
3080                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
3081            }
3082    
3083            /**
3084            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3085            *
3086            * @param id the primary key of the current journal article
3087            * @param groupId the group ID
3088            * @param urlTitle the url title
3089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3090            * @return the previous, current, and next journal article
3091            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3092            * @throws SystemException if a system exception occurred
3093            */
3094            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
3095                    long id, long groupId, java.lang.String urlTitle,
3096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3097                    throws com.liferay.portal.kernel.exception.SystemException,
3098                            com.liferay.portlet.journal.NoSuchArticleException {
3099                    return getPersistence()
3100                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
3101                            orderByComparator);
3102            }
3103    
3104            /**
3105            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3106            *
3107            * @param groupId the group ID
3108            * @param urlTitle the url title
3109            * @return the matching journal articles that the user has permission to view
3110            * @throws SystemException if a system exception occurred
3111            */
3112            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3113                    long groupId, java.lang.String urlTitle)
3114                    throws com.liferay.portal.kernel.exception.SystemException {
3115                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
3116            }
3117    
3118            /**
3119            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3120            *
3121            * <p>
3122            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3123            * </p>
3124            *
3125            * @param groupId the group ID
3126            * @param urlTitle the url title
3127            * @param start the lower bound of the range of journal articles
3128            * @param end the upper bound of the range of journal articles (not inclusive)
3129            * @return the range of matching journal articles that the user has permission to view
3130            * @throws SystemException if a system exception occurred
3131            */
3132            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3133                    long groupId, java.lang.String urlTitle, int start, int end)
3134                    throws com.liferay.portal.kernel.exception.SystemException {
3135                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
3136            }
3137    
3138            /**
3139            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
3140            *
3141            * <p>
3142            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3143            * </p>
3144            *
3145            * @param groupId the group ID
3146            * @param urlTitle the url title
3147            * @param start the lower bound of the range of journal articles
3148            * @param end the upper bound of the range of journal articles (not inclusive)
3149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3150            * @return the ordered range of matching journal articles that the user has permission to view
3151            * @throws SystemException if a system exception occurred
3152            */
3153            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3154                    long groupId, java.lang.String urlTitle, int start, int end,
3155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3156                    throws com.liferay.portal.kernel.exception.SystemException {
3157                    return getPersistence()
3158                                       .filterFindByG_UT(groupId, urlTitle, start, end,
3159                            orderByComparator);
3160            }
3161    
3162            /**
3163            * 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;.
3164            *
3165            * @param id the primary key of the current journal article
3166            * @param groupId the group ID
3167            * @param urlTitle the url title
3168            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3169            * @return the previous, current, and next journal article
3170            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3171            * @throws SystemException if a system exception occurred
3172            */
3173            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
3174                    long id, long groupId, java.lang.String urlTitle,
3175                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3176                    throws com.liferay.portal.kernel.exception.SystemException,
3177                            com.liferay.portlet.journal.NoSuchArticleException {
3178                    return getPersistence()
3179                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
3180                            orderByComparator);
3181            }
3182    
3183            /**
3184            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3185            *
3186            * @param groupId the group ID
3187            * @param urlTitle the url title
3188            * @throws SystemException if a system exception occurred
3189            */
3190            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
3191                    throws com.liferay.portal.kernel.exception.SystemException {
3192                    getPersistence().removeByG_UT(groupId, urlTitle);
3193            }
3194    
3195            /**
3196            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3197            *
3198            * @param groupId the group ID
3199            * @param urlTitle the url title
3200            * @return the number of matching journal articles
3201            * @throws SystemException if a system exception occurred
3202            */
3203            public static int countByG_UT(long groupId, java.lang.String urlTitle)
3204                    throws com.liferay.portal.kernel.exception.SystemException {
3205                    return getPersistence().countByG_UT(groupId, urlTitle);
3206            }
3207    
3208            /**
3209            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3210            *
3211            * @param groupId the group ID
3212            * @param urlTitle the url title
3213            * @return the number of matching journal articles that the user has permission to view
3214            * @throws SystemException if a system exception occurred
3215            */
3216            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
3217                    throws com.liferay.portal.kernel.exception.SystemException {
3218                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3219            }
3220    
3221            /**
3222            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
3223            *
3224            * @param groupId the group ID
3225            * @param structureId the structure ID
3226            * @return the matching journal articles
3227            * @throws SystemException if a system exception occurred
3228            */
3229            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3230                    long groupId, java.lang.String structureId)
3231                    throws com.liferay.portal.kernel.exception.SystemException {
3232                    return getPersistence().findByG_S(groupId, structureId);
3233            }
3234    
3235            /**
3236            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
3237            *
3238            * <p>
3239            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3240            * </p>
3241            *
3242            * @param groupId the group ID
3243            * @param structureId the structure ID
3244            * @param start the lower bound of the range of journal articles
3245            * @param end the upper bound of the range of journal articles (not inclusive)
3246            * @return the range of matching journal articles
3247            * @throws SystemException if a system exception occurred
3248            */
3249            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3250                    long groupId, java.lang.String structureId, int start, int end)
3251                    throws com.liferay.portal.kernel.exception.SystemException {
3252                    return getPersistence().findByG_S(groupId, structureId, start, end);
3253            }
3254    
3255            /**
3256            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
3257            *
3258            * <p>
3259            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3260            * </p>
3261            *
3262            * @param groupId the group ID
3263            * @param structureId the structure ID
3264            * @param start the lower bound of the range of journal articles
3265            * @param end the upper bound of the range of journal articles (not inclusive)
3266            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3267            * @return the ordered range of matching journal articles
3268            * @throws SystemException if a system exception occurred
3269            */
3270            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3271                    long groupId, java.lang.String structureId, int start, int end,
3272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3273                    throws com.liferay.portal.kernel.exception.SystemException {
3274                    return getPersistence()
3275                                       .findByG_S(groupId, structureId, start, end,
3276                            orderByComparator);
3277            }
3278    
3279            /**
3280            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3281            *
3282            * @param groupId the group ID
3283            * @param structureId the structure ID
3284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3285            * @return the first matching journal article
3286            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3287            * @throws SystemException if a system exception occurred
3288            */
3289            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
3290                    long groupId, java.lang.String structureId,
3291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3292                    throws com.liferay.portal.kernel.exception.SystemException,
3293                            com.liferay.portlet.journal.NoSuchArticleException {
3294                    return getPersistence()
3295                                       .findByG_S_First(groupId, structureId, orderByComparator);
3296            }
3297    
3298            /**
3299            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3300            *
3301            * @param groupId the group ID
3302            * @param structureId the structure ID
3303            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3304            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3305            * @throws SystemException if a system exception occurred
3306            */
3307            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
3308                    long groupId, java.lang.String structureId,
3309                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3310                    throws com.liferay.portal.kernel.exception.SystemException {
3311                    return getPersistence()
3312                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
3313            }
3314    
3315            /**
3316            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3317            *
3318            * @param groupId the group ID
3319            * @param structureId the structure ID
3320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3321            * @return the last matching journal article
3322            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3323            * @throws SystemException if a system exception occurred
3324            */
3325            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
3326                    long groupId, java.lang.String structureId,
3327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3328                    throws com.liferay.portal.kernel.exception.SystemException,
3329                            com.liferay.portlet.journal.NoSuchArticleException {
3330                    return getPersistence()
3331                                       .findByG_S_Last(groupId, structureId, orderByComparator);
3332            }
3333    
3334            /**
3335            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3336            *
3337            * @param groupId the group ID
3338            * @param structureId the structure ID
3339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3340            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3341            * @throws SystemException if a system exception occurred
3342            */
3343            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
3344                    long groupId, java.lang.String structureId,
3345                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3346                    throws com.liferay.portal.kernel.exception.SystemException {
3347                    return getPersistence()
3348                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
3349            }
3350    
3351            /**
3352            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3353            *
3354            * @param id the primary key of the current journal article
3355            * @param groupId the group ID
3356            * @param structureId the structure ID
3357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3358            * @return the previous, current, and next journal article
3359            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3360            * @throws SystemException if a system exception occurred
3361            */
3362            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
3363                    long id, long groupId, java.lang.String structureId,
3364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3365                    throws com.liferay.portal.kernel.exception.SystemException,
3366                            com.liferay.portlet.journal.NoSuchArticleException {
3367                    return getPersistence()
3368                                       .findByG_S_PrevAndNext(id, groupId, structureId,
3369                            orderByComparator);
3370            }
3371    
3372            /**
3373            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3374            *
3375            * @param groupId the group ID
3376            * @param structureId the structure ID
3377            * @return the matching journal articles that the user has permission to view
3378            * @throws SystemException if a system exception occurred
3379            */
3380            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3381                    long groupId, java.lang.String structureId)
3382                    throws com.liferay.portal.kernel.exception.SystemException {
3383                    return getPersistence().filterFindByG_S(groupId, structureId);
3384            }
3385    
3386            /**
3387            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3388            *
3389            * <p>
3390            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3391            * </p>
3392            *
3393            * @param groupId the group ID
3394            * @param structureId the structure ID
3395            * @param start the lower bound of the range of journal articles
3396            * @param end the upper bound of the range of journal articles (not inclusive)
3397            * @return the range of matching journal articles that the user has permission to view
3398            * @throws SystemException if a system exception occurred
3399            */
3400            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3401                    long groupId, java.lang.String structureId, int start, int end)
3402                    throws com.liferay.portal.kernel.exception.SystemException {
3403                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
3404            }
3405    
3406            /**
3407            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
3408            *
3409            * <p>
3410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3411            * </p>
3412            *
3413            * @param groupId the group ID
3414            * @param structureId the structure ID
3415            * @param start the lower bound of the range of journal articles
3416            * @param end the upper bound of the range of journal articles (not inclusive)
3417            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3418            * @return the ordered range of matching journal articles that the user has permission to view
3419            * @throws SystemException if a system exception occurred
3420            */
3421            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3422                    long groupId, java.lang.String structureId, int start, int end,
3423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3424                    throws com.liferay.portal.kernel.exception.SystemException {
3425                    return getPersistence()
3426                                       .filterFindByG_S(groupId, structureId, start, end,
3427                            orderByComparator);
3428            }
3429    
3430            /**
3431            * 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;.
3432            *
3433            * @param id the primary key of the current journal article
3434            * @param groupId the group ID
3435            * @param structureId the structure ID
3436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3437            * @return the previous, current, and next journal article
3438            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3439            * @throws SystemException if a system exception occurred
3440            */
3441            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
3442                    long id, long groupId, java.lang.String structureId,
3443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3444                    throws com.liferay.portal.kernel.exception.SystemException,
3445                            com.liferay.portlet.journal.NoSuchArticleException {
3446                    return getPersistence()
3447                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
3448                            orderByComparator);
3449            }
3450    
3451            /**
3452            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
3453            *
3454            * @param groupId the group ID
3455            * @param structureId the structure ID
3456            * @throws SystemException if a system exception occurred
3457            */
3458            public static void removeByG_S(long groupId, java.lang.String structureId)
3459                    throws com.liferay.portal.kernel.exception.SystemException {
3460                    getPersistence().removeByG_S(groupId, structureId);
3461            }
3462    
3463            /**
3464            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
3465            *
3466            * @param groupId the group ID
3467            * @param structureId the structure ID
3468            * @return the number of matching journal articles
3469            * @throws SystemException if a system exception occurred
3470            */
3471            public static int countByG_S(long groupId, java.lang.String structureId)
3472                    throws com.liferay.portal.kernel.exception.SystemException {
3473                    return getPersistence().countByG_S(groupId, structureId);
3474            }
3475    
3476            /**
3477            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3478            *
3479            * @param groupId the group ID
3480            * @param structureId the structure ID
3481            * @return the number of matching journal articles that the user has permission to view
3482            * @throws SystemException if a system exception occurred
3483            */
3484            public static int filterCountByG_S(long groupId,
3485                    java.lang.String structureId)
3486                    throws com.liferay.portal.kernel.exception.SystemException {
3487                    return getPersistence().filterCountByG_S(groupId, structureId);
3488            }
3489    
3490            /**
3491            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
3492            *
3493            * @param groupId the group ID
3494            * @param templateId the template ID
3495            * @return the matching journal articles
3496            * @throws SystemException if a system exception occurred
3497            */
3498            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3499                    long groupId, java.lang.String templateId)
3500                    throws com.liferay.portal.kernel.exception.SystemException {
3501                    return getPersistence().findByG_T(groupId, templateId);
3502            }
3503    
3504            /**
3505            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
3506            *
3507            * <p>
3508            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3509            * </p>
3510            *
3511            * @param groupId the group ID
3512            * @param templateId the template ID
3513            * @param start the lower bound of the range of journal articles
3514            * @param end the upper bound of the range of journal articles (not inclusive)
3515            * @return the range of matching journal articles
3516            * @throws SystemException if a system exception occurred
3517            */
3518            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3519                    long groupId, java.lang.String templateId, int start, int end)
3520                    throws com.liferay.portal.kernel.exception.SystemException {
3521                    return getPersistence().findByG_T(groupId, templateId, start, end);
3522            }
3523    
3524            /**
3525            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
3526            *
3527            * <p>
3528            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3529            * </p>
3530            *
3531            * @param groupId the group ID
3532            * @param templateId the template ID
3533            * @param start the lower bound of the range of journal articles
3534            * @param end the upper bound of the range of journal articles (not inclusive)
3535            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3536            * @return the ordered range of matching journal articles
3537            * @throws SystemException if a system exception occurred
3538            */
3539            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3540                    long groupId, java.lang.String templateId, int start, int end,
3541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3542                    throws com.liferay.portal.kernel.exception.SystemException {
3543                    return getPersistence()
3544                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
3545            }
3546    
3547            /**
3548            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3549            *
3550            * @param groupId the group ID
3551            * @param templateId the template ID
3552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3553            * @return the first matching journal article
3554            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3555            * @throws SystemException if a system exception occurred
3556            */
3557            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
3558                    long groupId, java.lang.String templateId,
3559                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3560                    throws com.liferay.portal.kernel.exception.SystemException,
3561                            com.liferay.portlet.journal.NoSuchArticleException {
3562                    return getPersistence()
3563                                       .findByG_T_First(groupId, templateId, orderByComparator);
3564            }
3565    
3566            /**
3567            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3568            *
3569            * @param groupId the group ID
3570            * @param templateId the template ID
3571            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3572            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3573            * @throws SystemException if a system exception occurred
3574            */
3575            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
3576                    long groupId, java.lang.String templateId,
3577                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3578                    throws com.liferay.portal.kernel.exception.SystemException {
3579                    return getPersistence()
3580                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
3581            }
3582    
3583            /**
3584            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3585            *
3586            * @param groupId the group ID
3587            * @param templateId the template ID
3588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3589            * @return the last matching journal article
3590            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3591            * @throws SystemException if a system exception occurred
3592            */
3593            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
3594                    long groupId, java.lang.String templateId,
3595                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3596                    throws com.liferay.portal.kernel.exception.SystemException,
3597                            com.liferay.portlet.journal.NoSuchArticleException {
3598                    return getPersistence()
3599                                       .findByG_T_Last(groupId, templateId, orderByComparator);
3600            }
3601    
3602            /**
3603            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3604            *
3605            * @param groupId the group ID
3606            * @param templateId the template ID
3607            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3608            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3609            * @throws SystemException if a system exception occurred
3610            */
3611            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last(
3612                    long groupId, java.lang.String templateId,
3613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3614                    throws com.liferay.portal.kernel.exception.SystemException {
3615                    return getPersistence()
3616                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
3617            }
3618    
3619            /**
3620            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3621            *
3622            * @param id the primary key of the current journal article
3623            * @param groupId the group ID
3624            * @param templateId the template ID
3625            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3626            * @return the previous, current, and next journal article
3627            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3628            * @throws SystemException if a system exception occurred
3629            */
3630            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
3631                    long id, long groupId, java.lang.String templateId,
3632                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3633                    throws com.liferay.portal.kernel.exception.SystemException,
3634                            com.liferay.portlet.journal.NoSuchArticleException {
3635                    return getPersistence()
3636                                       .findByG_T_PrevAndNext(id, groupId, templateId,
3637                            orderByComparator);
3638            }
3639    
3640            /**
3641            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3642            *
3643            * @param groupId the group ID
3644            * @param templateId the template ID
3645            * @return the matching journal articles that the user has permission to view
3646            * @throws SystemException if a system exception occurred
3647            */
3648            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3649                    long groupId, java.lang.String templateId)
3650                    throws com.liferay.portal.kernel.exception.SystemException {
3651                    return getPersistence().filterFindByG_T(groupId, templateId);
3652            }
3653    
3654            /**
3655            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3656            *
3657            * <p>
3658            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3659            * </p>
3660            *
3661            * @param groupId the group ID
3662            * @param templateId the template ID
3663            * @param start the lower bound of the range of journal articles
3664            * @param end the upper bound of the range of journal articles (not inclusive)
3665            * @return the range of matching journal articles that the user has permission to view
3666            * @throws SystemException if a system exception occurred
3667            */
3668            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3669                    long groupId, java.lang.String templateId, int start, int end)
3670                    throws com.liferay.portal.kernel.exception.SystemException {
3671                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
3672            }
3673    
3674            /**
3675            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
3676            *
3677            * <p>
3678            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3679            * </p>
3680            *
3681            * @param groupId the group ID
3682            * @param templateId the template ID
3683            * @param start the lower bound of the range of journal articles
3684            * @param end the upper bound of the range of journal articles (not inclusive)
3685            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3686            * @return the ordered range of matching journal articles that the user has permission to view
3687            * @throws SystemException if a system exception occurred
3688            */
3689            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3690                    long groupId, java.lang.String templateId, int start, int end,
3691                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3692                    throws com.liferay.portal.kernel.exception.SystemException {
3693                    return getPersistence()
3694                                       .filterFindByG_T(groupId, templateId, start, end,
3695                            orderByComparator);
3696            }
3697    
3698            /**
3699            * 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;.
3700            *
3701            * @param id the primary key of the current journal article
3702            * @param groupId the group ID
3703            * @param templateId the template ID
3704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3705            * @return the previous, current, and next journal article
3706            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3707            * @throws SystemException if a system exception occurred
3708            */
3709            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
3710                    long id, long groupId, java.lang.String templateId,
3711                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3712                    throws com.liferay.portal.kernel.exception.SystemException,
3713                            com.liferay.portlet.journal.NoSuchArticleException {
3714                    return getPersistence()
3715                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
3716                            orderByComparator);
3717            }
3718    
3719            /**
3720            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
3721            *
3722            * @param groupId the group ID
3723            * @param templateId the template ID
3724            * @throws SystemException if a system exception occurred
3725            */
3726            public static void removeByG_T(long groupId, java.lang.String templateId)
3727                    throws com.liferay.portal.kernel.exception.SystemException {
3728                    getPersistence().removeByG_T(groupId, templateId);
3729            }
3730    
3731            /**
3732            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
3733            *
3734            * @param groupId the group ID
3735            * @param templateId the template ID
3736            * @return the number of matching journal articles
3737            * @throws SystemException if a system exception occurred
3738            */
3739            public static int countByG_T(long groupId, java.lang.String templateId)
3740                    throws com.liferay.portal.kernel.exception.SystemException {
3741                    return getPersistence().countByG_T(groupId, templateId);
3742            }
3743    
3744            /**
3745            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3746            *
3747            * @param groupId the group ID
3748            * @param templateId the template ID
3749            * @return the number of matching journal articles that the user has permission to view
3750            * @throws SystemException if a system exception occurred
3751            */
3752            public static int filterCountByG_T(long groupId, java.lang.String templateId)
3753                    throws com.liferay.portal.kernel.exception.SystemException {
3754                    return getPersistence().filterCountByG_T(groupId, templateId);
3755            }
3756    
3757            /**
3758            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3759            *
3760            * @param groupId the group ID
3761            * @param layoutUuid the layout uuid
3762            * @return the matching journal articles
3763            * @throws SystemException if a system exception occurred
3764            */
3765            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3766                    long groupId, java.lang.String layoutUuid)
3767                    throws com.liferay.portal.kernel.exception.SystemException {
3768                    return getPersistence().findByG_L(groupId, layoutUuid);
3769            }
3770    
3771            /**
3772            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3773            *
3774            * <p>
3775            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3776            * </p>
3777            *
3778            * @param groupId the group ID
3779            * @param layoutUuid the layout uuid
3780            * @param start the lower bound of the range of journal articles
3781            * @param end the upper bound of the range of journal articles (not inclusive)
3782            * @return the range of matching journal articles
3783            * @throws SystemException if a system exception occurred
3784            */
3785            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3786                    long groupId, java.lang.String layoutUuid, int start, int end)
3787                    throws com.liferay.portal.kernel.exception.SystemException {
3788                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
3789            }
3790    
3791            /**
3792            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3793            *
3794            * <p>
3795            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3796            * </p>
3797            *
3798            * @param groupId the group ID
3799            * @param layoutUuid the layout uuid
3800            * @param start the lower bound of the range of journal articles
3801            * @param end the upper bound of the range of journal articles (not inclusive)
3802            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3803            * @return the ordered range of matching journal articles
3804            * @throws SystemException if a system exception occurred
3805            */
3806            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3807                    long groupId, java.lang.String layoutUuid, int start, int end,
3808                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3809                    throws com.liferay.portal.kernel.exception.SystemException {
3810                    return getPersistence()
3811                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
3812            }
3813    
3814            /**
3815            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3816            *
3817            * @param groupId the group ID
3818            * @param layoutUuid the layout uuid
3819            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3820            * @return the first matching journal article
3821            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3822            * @throws SystemException if a system exception occurred
3823            */
3824            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
3825                    long groupId, java.lang.String layoutUuid,
3826                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3827                    throws com.liferay.portal.kernel.exception.SystemException,
3828                            com.liferay.portlet.journal.NoSuchArticleException {
3829                    return getPersistence()
3830                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
3831            }
3832    
3833            /**
3834            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3835            *
3836            * @param groupId the group ID
3837            * @param layoutUuid the layout uuid
3838            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3839            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3840            * @throws SystemException if a system exception occurred
3841            */
3842            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
3843                    long groupId, java.lang.String layoutUuid,
3844                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3845                    throws com.liferay.portal.kernel.exception.SystemException {
3846                    return getPersistence()
3847                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
3848            }
3849    
3850            /**
3851            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3852            *
3853            * @param groupId the group ID
3854            * @param layoutUuid the layout uuid
3855            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3856            * @return the last matching journal article
3857            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3858            * @throws SystemException if a system exception occurred
3859            */
3860            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
3861                    long groupId, java.lang.String layoutUuid,
3862                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3863                    throws com.liferay.portal.kernel.exception.SystemException,
3864                            com.liferay.portlet.journal.NoSuchArticleException {
3865                    return getPersistence()
3866                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
3867            }
3868    
3869            /**
3870            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3871            *
3872            * @param groupId the group ID
3873            * @param layoutUuid the layout uuid
3874            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3875            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3876            * @throws SystemException if a system exception occurred
3877            */
3878            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
3879                    long groupId, java.lang.String layoutUuid,
3880                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3881                    throws com.liferay.portal.kernel.exception.SystemException {
3882                    return getPersistence()
3883                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
3884            }
3885    
3886            /**
3887            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3888            *
3889            * @param id the primary key of the current journal article
3890            * @param groupId the group ID
3891            * @param layoutUuid the layout uuid
3892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3893            * @return the previous, current, and next journal article
3894            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3895            * @throws SystemException if a system exception occurred
3896            */
3897            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
3898                    long id, long groupId, java.lang.String layoutUuid,
3899                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3900                    throws com.liferay.portal.kernel.exception.SystemException,
3901                            com.liferay.portlet.journal.NoSuchArticleException {
3902                    return getPersistence()
3903                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
3904                            orderByComparator);
3905            }
3906    
3907            /**
3908            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3909            *
3910            * @param groupId the group ID
3911            * @param layoutUuid the layout uuid
3912            * @return the matching journal articles that the user has permission to view
3913            * @throws SystemException if a system exception occurred
3914            */
3915            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3916                    long groupId, java.lang.String layoutUuid)
3917                    throws com.liferay.portal.kernel.exception.SystemException {
3918                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
3919            }
3920    
3921            /**
3922            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3923            *
3924            * <p>
3925            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3926            * </p>
3927            *
3928            * @param groupId the group ID
3929            * @param layoutUuid the layout uuid
3930            * @param start the lower bound of the range of journal articles
3931            * @param end the upper bound of the range of journal articles (not inclusive)
3932            * @return the range of matching journal articles that the user has permission to view
3933            * @throws SystemException if a system exception occurred
3934            */
3935            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3936                    long groupId, java.lang.String layoutUuid, int start, int end)
3937                    throws com.liferay.portal.kernel.exception.SystemException {
3938                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
3939            }
3940    
3941            /**
3942            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
3943            *
3944            * <p>
3945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
3946            * </p>
3947            *
3948            * @param groupId the group ID
3949            * @param layoutUuid the layout uuid
3950            * @param start the lower bound of the range of journal articles
3951            * @param end the upper bound of the range of journal articles (not inclusive)
3952            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3953            * @return the ordered range of matching journal articles that the user has permission to view
3954            * @throws SystemException if a system exception occurred
3955            */
3956            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3957                    long groupId, java.lang.String layoutUuid, int start, int end,
3958                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3959                    throws com.liferay.portal.kernel.exception.SystemException {
3960                    return getPersistence()
3961                                       .filterFindByG_L(groupId, layoutUuid, start, end,
3962                            orderByComparator);
3963            }
3964    
3965            /**
3966            * 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;.
3967            *
3968            * @param id the primary key of the current journal article
3969            * @param groupId the group ID
3970            * @param layoutUuid the layout uuid
3971            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3972            * @return the previous, current, and next journal article
3973            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3974            * @throws SystemException if a system exception occurred
3975            */
3976            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
3977                    long id, long groupId, java.lang.String layoutUuid,
3978                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3979                    throws com.liferay.portal.kernel.exception.SystemException,
3980                            com.liferay.portlet.journal.NoSuchArticleException {
3981                    return getPersistence()
3982                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
3983                            orderByComparator);
3984            }
3985    
3986            /**
3987            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
3988            *
3989            * @param groupId the group ID
3990            * @param layoutUuid the layout uuid
3991            * @throws SystemException if a system exception occurred
3992            */
3993            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
3994                    throws com.liferay.portal.kernel.exception.SystemException {
3995                    getPersistence().removeByG_L(groupId, layoutUuid);
3996            }
3997    
3998            /**
3999            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4000            *
4001            * @param groupId the group ID
4002            * @param layoutUuid the layout uuid
4003            * @return the number of matching journal articles
4004            * @throws SystemException if a system exception occurred
4005            */
4006            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4007                    throws com.liferay.portal.kernel.exception.SystemException {
4008                    return getPersistence().countByG_L(groupId, layoutUuid);
4009            }
4010    
4011            /**
4012            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4013            *
4014            * @param groupId the group ID
4015            * @param layoutUuid the layout uuid
4016            * @return the number of matching journal articles that the user has permission to view
4017            * @throws SystemException if a system exception occurred
4018            */
4019            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4020                    throws com.liferay.portal.kernel.exception.SystemException {
4021                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4022            }
4023    
4024            /**
4025            * Returns all the journal articles where groupId = &#63; and status = &#63;.
4026            *
4027            * @param groupId the group ID
4028            * @param status the status
4029            * @return the matching journal articles
4030            * @throws SystemException if a system exception occurred
4031            */
4032            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4033                    long groupId, int status)
4034                    throws com.liferay.portal.kernel.exception.SystemException {
4035                    return getPersistence().findByG_ST(groupId, status);
4036            }
4037    
4038            /**
4039            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
4040            *
4041            * <p>
4042            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4043            * </p>
4044            *
4045            * @param groupId the group ID
4046            * @param status the status
4047            * @param start the lower bound of the range of journal articles
4048            * @param end the upper bound of the range of journal articles (not inclusive)
4049            * @return the range of matching journal articles
4050            * @throws SystemException if a system exception occurred
4051            */
4052            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4053                    long groupId, int status, int start, int end)
4054                    throws com.liferay.portal.kernel.exception.SystemException {
4055                    return getPersistence().findByG_ST(groupId, status, start, end);
4056            }
4057    
4058            /**
4059            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
4060            *
4061            * <p>
4062            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4063            * </p>
4064            *
4065            * @param groupId the group ID
4066            * @param status the status
4067            * @param start the lower bound of the range of journal articles
4068            * @param end the upper bound of the range of journal articles (not inclusive)
4069            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4070            * @return the ordered range of matching journal articles
4071            * @throws SystemException if a system exception occurred
4072            */
4073            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4074                    long groupId, int status, int start, int end,
4075                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4076                    throws com.liferay.portal.kernel.exception.SystemException {
4077                    return getPersistence()
4078                                       .findByG_ST(groupId, status, start, end, orderByComparator);
4079            }
4080    
4081            /**
4082            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4083            *
4084            * @param groupId the group ID
4085            * @param status the status
4086            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4087            * @return the first matching journal article
4088            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4089            * @throws SystemException if a system exception occurred
4090            */
4091            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
4092                    long groupId, int status,
4093                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4094                    throws com.liferay.portal.kernel.exception.SystemException,
4095                            com.liferay.portlet.journal.NoSuchArticleException {
4096                    return getPersistence()
4097                                       .findByG_ST_First(groupId, status, orderByComparator);
4098            }
4099    
4100            /**
4101            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4102            *
4103            * @param groupId the group ID
4104            * @param status the status
4105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4106            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4107            * @throws SystemException if a system exception occurred
4108            */
4109            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
4110                    long groupId, int status,
4111                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4112                    throws com.liferay.portal.kernel.exception.SystemException {
4113                    return getPersistence()
4114                                       .fetchByG_ST_First(groupId, status, orderByComparator);
4115            }
4116    
4117            /**
4118            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4119            *
4120            * @param groupId the group ID
4121            * @param status the status
4122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4123            * @return the last matching journal article
4124            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4125            * @throws SystemException if a system exception occurred
4126            */
4127            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
4128                    long groupId, int status,
4129                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4130                    throws com.liferay.portal.kernel.exception.SystemException,
4131                            com.liferay.portlet.journal.NoSuchArticleException {
4132                    return getPersistence()
4133                                       .findByG_ST_Last(groupId, status, orderByComparator);
4134            }
4135    
4136            /**
4137            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4138            *
4139            * @param groupId the group ID
4140            * @param status the status
4141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4142            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4143            * @throws SystemException if a system exception occurred
4144            */
4145            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last(
4146                    long groupId, int status,
4147                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4148                    throws com.liferay.portal.kernel.exception.SystemException {
4149                    return getPersistence()
4150                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
4151            }
4152    
4153            /**
4154            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
4155            *
4156            * @param id the primary key of the current journal article
4157            * @param groupId the group ID
4158            * @param status the status
4159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4160            * @return the previous, current, and next journal article
4161            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4162            * @throws SystemException if a system exception occurred
4163            */
4164            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
4165                    long id, long groupId, int status,
4166                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4167                    throws com.liferay.portal.kernel.exception.SystemException,
4168                            com.liferay.portlet.journal.NoSuchArticleException {
4169                    return getPersistence()
4170                                       .findByG_ST_PrevAndNext(id, groupId, status,
4171                            orderByComparator);
4172            }
4173    
4174            /**
4175            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4176            *
4177            * @param groupId the group ID
4178            * @param status the status
4179            * @return the matching journal articles that the user has permission to view
4180            * @throws SystemException if a system exception occurred
4181            */
4182            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4183                    long groupId, int status)
4184                    throws com.liferay.portal.kernel.exception.SystemException {
4185                    return getPersistence().filterFindByG_ST(groupId, status);
4186            }
4187    
4188            /**
4189            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4190            *
4191            * <p>
4192            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4193            * </p>
4194            *
4195            * @param groupId the group ID
4196            * @param status the status
4197            * @param start the lower bound of the range of journal articles
4198            * @param end the upper bound of the range of journal articles (not inclusive)
4199            * @return the range of matching journal articles that the user has permission to view
4200            * @throws SystemException if a system exception occurred
4201            */
4202            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4203                    long groupId, int status, int start, int end)
4204                    throws com.liferay.portal.kernel.exception.SystemException {
4205                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
4206            }
4207    
4208            /**
4209            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
4210            *
4211            * <p>
4212            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4213            * </p>
4214            *
4215            * @param groupId the group ID
4216            * @param status the status
4217            * @param start the lower bound of the range of journal articles
4218            * @param end the upper bound of the range of journal articles (not inclusive)
4219            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4220            * @return the ordered range of matching journal articles that the user has permission to view
4221            * @throws SystemException if a system exception occurred
4222            */
4223            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4224                    long groupId, int status, int start, int end,
4225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4226                    throws com.liferay.portal.kernel.exception.SystemException {
4227                    return getPersistence()
4228                                       .filterFindByG_ST(groupId, status, start, end,
4229                            orderByComparator);
4230            }
4231    
4232            /**
4233            * 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;.
4234            *
4235            * @param id the primary key of the current journal article
4236            * @param groupId the group ID
4237            * @param status the status
4238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4239            * @return the previous, current, and next journal article
4240            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4241            * @throws SystemException if a system exception occurred
4242            */
4243            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
4244                    long id, long groupId, int status,
4245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4246                    throws com.liferay.portal.kernel.exception.SystemException,
4247                            com.liferay.portlet.journal.NoSuchArticleException {
4248                    return getPersistence()
4249                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
4250                            orderByComparator);
4251            }
4252    
4253            /**
4254            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4255            *
4256            * @param groupId the group ID
4257            * @param status the status
4258            * @throws SystemException if a system exception occurred
4259            */
4260            public static void removeByG_ST(long groupId, int status)
4261                    throws com.liferay.portal.kernel.exception.SystemException {
4262                    getPersistence().removeByG_ST(groupId, status);
4263            }
4264    
4265            /**
4266            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4267            *
4268            * @param groupId the group ID
4269            * @param status the status
4270            * @return the number of matching journal articles
4271            * @throws SystemException if a system exception occurred
4272            */
4273            public static int countByG_ST(long groupId, int status)
4274                    throws com.liferay.portal.kernel.exception.SystemException {
4275                    return getPersistence().countByG_ST(groupId, status);
4276            }
4277    
4278            /**
4279            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4280            *
4281            * @param groupId the group ID
4282            * @param status the status
4283            * @return the number of matching journal articles that the user has permission to view
4284            * @throws SystemException if a system exception occurred
4285            */
4286            public static int filterCountByG_ST(long groupId, int status)
4287                    throws com.liferay.portal.kernel.exception.SystemException {
4288                    return getPersistence().filterCountByG_ST(groupId, status);
4289            }
4290    
4291            /**
4292            * Returns all the journal articles where companyId = &#63; and version = &#63;.
4293            *
4294            * @param companyId the company ID
4295            * @param version the version
4296            * @return the matching journal articles
4297            * @throws SystemException if a system exception occurred
4298            */
4299            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4300                    long companyId, double version)
4301                    throws com.liferay.portal.kernel.exception.SystemException {
4302                    return getPersistence().findByC_V(companyId, version);
4303            }
4304    
4305            /**
4306            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4307            *
4308            * <p>
4309            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4310            * </p>
4311            *
4312            * @param companyId the company ID
4313            * @param version the version
4314            * @param start the lower bound of the range of journal articles
4315            * @param end the upper bound of the range of journal articles (not inclusive)
4316            * @return the range of matching journal articles
4317            * @throws SystemException if a system exception occurred
4318            */
4319            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4320                    long companyId, double version, int start, int end)
4321                    throws com.liferay.portal.kernel.exception.SystemException {
4322                    return getPersistence().findByC_V(companyId, version, start, end);
4323            }
4324    
4325            /**
4326            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
4327            *
4328            * <p>
4329            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4330            * </p>
4331            *
4332            * @param companyId the company ID
4333            * @param version the version
4334            * @param start the lower bound of the range of journal articles
4335            * @param end the upper bound of the range of journal articles (not inclusive)
4336            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4337            * @return the ordered range of matching journal articles
4338            * @throws SystemException if a system exception occurred
4339            */
4340            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4341                    long companyId, double version, int start, int end,
4342                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4343                    throws com.liferay.portal.kernel.exception.SystemException {
4344                    return getPersistence()
4345                                       .findByC_V(companyId, version, start, end, orderByComparator);
4346            }
4347    
4348            /**
4349            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4350            *
4351            * @param companyId the company ID
4352            * @param version the version
4353            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4354            * @return the first matching journal article
4355            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4356            * @throws SystemException if a system exception occurred
4357            */
4358            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
4359                    long companyId, double version,
4360                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4361                    throws com.liferay.portal.kernel.exception.SystemException,
4362                            com.liferay.portlet.journal.NoSuchArticleException {
4363                    return getPersistence()
4364                                       .findByC_V_First(companyId, version, orderByComparator);
4365            }
4366    
4367            /**
4368            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4369            *
4370            * @param companyId the company ID
4371            * @param version the version
4372            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4373            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4374            * @throws SystemException if a system exception occurred
4375            */
4376            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
4377                    long companyId, double version,
4378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4379                    throws com.liferay.portal.kernel.exception.SystemException {
4380                    return getPersistence()
4381                                       .fetchByC_V_First(companyId, version, orderByComparator);
4382            }
4383    
4384            /**
4385            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4386            *
4387            * @param companyId the company ID
4388            * @param version the version
4389            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4390            * @return the last matching journal article
4391            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4392            * @throws SystemException if a system exception occurred
4393            */
4394            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
4395                    long companyId, double version,
4396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4397                    throws com.liferay.portal.kernel.exception.SystemException,
4398                            com.liferay.portlet.journal.NoSuchArticleException {
4399                    return getPersistence()
4400                                       .findByC_V_Last(companyId, version, orderByComparator);
4401            }
4402    
4403            /**
4404            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4405            *
4406            * @param companyId the company ID
4407            * @param version the version
4408            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4409            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4410            * @throws SystemException if a system exception occurred
4411            */
4412            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
4413                    long companyId, double version,
4414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4415                    throws com.liferay.portal.kernel.exception.SystemException {
4416                    return getPersistence()
4417                                       .fetchByC_V_Last(companyId, version, orderByComparator);
4418            }
4419    
4420            /**
4421            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
4422            *
4423            * @param id the primary key of the current journal article
4424            * @param companyId the company ID
4425            * @param version the version
4426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4427            * @return the previous, current, and next journal article
4428            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4429            * @throws SystemException if a system exception occurred
4430            */
4431            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
4432                    long id, long companyId, double version,
4433                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4434                    throws com.liferay.portal.kernel.exception.SystemException,
4435                            com.liferay.portlet.journal.NoSuchArticleException {
4436                    return getPersistence()
4437                                       .findByC_V_PrevAndNext(id, companyId, version,
4438                            orderByComparator);
4439            }
4440    
4441            /**
4442            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4443            *
4444            * @param companyId the company ID
4445            * @param version the version
4446            * @throws SystemException if a system exception occurred
4447            */
4448            public static void removeByC_V(long companyId, double version)
4449                    throws com.liferay.portal.kernel.exception.SystemException {
4450                    getPersistence().removeByC_V(companyId, version);
4451            }
4452    
4453            /**
4454            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4455            *
4456            * @param companyId the company ID
4457            * @param version the version
4458            * @return the number of matching journal articles
4459            * @throws SystemException if a system exception occurred
4460            */
4461            public static int countByC_V(long companyId, double version)
4462                    throws com.liferay.portal.kernel.exception.SystemException {
4463                    return getPersistence().countByC_V(companyId, version);
4464            }
4465    
4466            /**
4467            * Returns all the journal articles where companyId = &#63; and status = &#63;.
4468            *
4469            * @param companyId the company ID
4470            * @param status the status
4471            * @return the matching journal articles
4472            * @throws SystemException if a system exception occurred
4473            */
4474            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4475                    long companyId, int status)
4476                    throws com.liferay.portal.kernel.exception.SystemException {
4477                    return getPersistence().findByC_ST(companyId, status);
4478            }
4479    
4480            /**
4481            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
4482            *
4483            * <p>
4484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4485            * </p>
4486            *
4487            * @param companyId the company ID
4488            * @param status the status
4489            * @param start the lower bound of the range of journal articles
4490            * @param end the upper bound of the range of journal articles (not inclusive)
4491            * @return the range of matching journal articles
4492            * @throws SystemException if a system exception occurred
4493            */
4494            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4495                    long companyId, int status, int start, int end)
4496                    throws com.liferay.portal.kernel.exception.SystemException {
4497                    return getPersistence().findByC_ST(companyId, status, start, end);
4498            }
4499    
4500            /**
4501            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
4502            *
4503            * <p>
4504            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4505            * </p>
4506            *
4507            * @param companyId the company ID
4508            * @param status the status
4509            * @param start the lower bound of the range of journal articles
4510            * @param end the upper bound of the range of journal articles (not inclusive)
4511            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4512            * @return the ordered range of matching journal articles
4513            * @throws SystemException if a system exception occurred
4514            */
4515            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4516                    long companyId, int status, int start, int end,
4517                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4518                    throws com.liferay.portal.kernel.exception.SystemException {
4519                    return getPersistence()
4520                                       .findByC_ST(companyId, status, start, end, orderByComparator);
4521            }
4522    
4523            /**
4524            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4525            *
4526            * @param companyId the company ID
4527            * @param status the status
4528            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4529            * @return the first matching journal article
4530            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4531            * @throws SystemException if a system exception occurred
4532            */
4533            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
4534                    long companyId, int status,
4535                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4536                    throws com.liferay.portal.kernel.exception.SystemException,
4537                            com.liferay.portlet.journal.NoSuchArticleException {
4538                    return getPersistence()
4539                                       .findByC_ST_First(companyId, status, orderByComparator);
4540            }
4541    
4542            /**
4543            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4544            *
4545            * @param companyId the company ID
4546            * @param status the status
4547            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4548            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4549            * @throws SystemException if a system exception occurred
4550            */
4551            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
4552                    long companyId, int status,
4553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4554                    throws com.liferay.portal.kernel.exception.SystemException {
4555                    return getPersistence()
4556                                       .fetchByC_ST_First(companyId, status, orderByComparator);
4557            }
4558    
4559            /**
4560            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4561            *
4562            * @param companyId the company ID
4563            * @param status the status
4564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4565            * @return the last matching journal article
4566            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4567            * @throws SystemException if a system exception occurred
4568            */
4569            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
4570                    long companyId, int status,
4571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4572                    throws com.liferay.portal.kernel.exception.SystemException,
4573                            com.liferay.portlet.journal.NoSuchArticleException {
4574                    return getPersistence()
4575                                       .findByC_ST_Last(companyId, status, orderByComparator);
4576            }
4577    
4578            /**
4579            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4580            *
4581            * @param companyId the company ID
4582            * @param status the status
4583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4584            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4585            * @throws SystemException if a system exception occurred
4586            */
4587            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
4588                    long companyId, int status,
4589                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4590                    throws com.liferay.portal.kernel.exception.SystemException {
4591                    return getPersistence()
4592                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
4593            }
4594    
4595            /**
4596            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
4597            *
4598            * @param id the primary key of the current journal article
4599            * @param companyId the company ID
4600            * @param status the status
4601            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4602            * @return the previous, current, and next journal article
4603            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4604            * @throws SystemException if a system exception occurred
4605            */
4606            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
4607                    long id, long companyId, int status,
4608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4609                    throws com.liferay.portal.kernel.exception.SystemException,
4610                            com.liferay.portlet.journal.NoSuchArticleException {
4611                    return getPersistence()
4612                                       .findByC_ST_PrevAndNext(id, companyId, status,
4613                            orderByComparator);
4614            }
4615    
4616            /**
4617            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4618            *
4619            * @param companyId the company ID
4620            * @param status the status
4621            * @throws SystemException if a system exception occurred
4622            */
4623            public static void removeByC_ST(long companyId, int status)
4624                    throws com.liferay.portal.kernel.exception.SystemException {
4625                    getPersistence().removeByC_ST(companyId, status);
4626            }
4627    
4628            /**
4629            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4630            *
4631            * @param companyId the company ID
4632            * @param status the status
4633            * @return the number of matching journal articles
4634            * @throws SystemException if a system exception occurred
4635            */
4636            public static int countByC_ST(long companyId, int status)
4637                    throws com.liferay.portal.kernel.exception.SystemException {
4638                    return getPersistence().countByC_ST(companyId, status);
4639            }
4640    
4641            /**
4642            * Returns all the journal articles where companyId = &#63; and status &ne; &#63;.
4643            *
4644            * @param companyId the company ID
4645            * @param status the status
4646            * @return the matching journal articles
4647            * @throws SystemException if a system exception occurred
4648            */
4649            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4650                    long companyId, int status)
4651                    throws com.liferay.portal.kernel.exception.SystemException {
4652                    return getPersistence().findByC_NotST(companyId, status);
4653            }
4654    
4655            /**
4656            * Returns a range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4657            *
4658            * <p>
4659            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4660            * </p>
4661            *
4662            * @param companyId the company ID
4663            * @param status the status
4664            * @param start the lower bound of the range of journal articles
4665            * @param end the upper bound of the range of journal articles (not inclusive)
4666            * @return the range of matching journal articles
4667            * @throws SystemException if a system exception occurred
4668            */
4669            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4670                    long companyId, int status, int start, int end)
4671                    throws com.liferay.portal.kernel.exception.SystemException {
4672                    return getPersistence().findByC_NotST(companyId, status, start, end);
4673            }
4674    
4675            /**
4676            * Returns an ordered range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4677            *
4678            * <p>
4679            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4680            * </p>
4681            *
4682            * @param companyId the company ID
4683            * @param status the status
4684            * @param start the lower bound of the range of journal articles
4685            * @param end the upper bound of the range of journal articles (not inclusive)
4686            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4687            * @return the ordered range of matching journal articles
4688            * @throws SystemException if a system exception occurred
4689            */
4690            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4691                    long companyId, int status, int start, int end,
4692                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4693                    throws com.liferay.portal.kernel.exception.SystemException {
4694                    return getPersistence()
4695                                       .findByC_NotST(companyId, status, start, end,
4696                            orderByComparator);
4697            }
4698    
4699            /**
4700            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4701            *
4702            * @param companyId the company ID
4703            * @param status the status
4704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4705            * @return the first matching journal article
4706            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4707            * @throws SystemException if a system exception occurred
4708            */
4709            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First(
4710                    long companyId, int status,
4711                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4712                    throws com.liferay.portal.kernel.exception.SystemException,
4713                            com.liferay.portlet.journal.NoSuchArticleException {
4714                    return getPersistence()
4715                                       .findByC_NotST_First(companyId, status, orderByComparator);
4716            }
4717    
4718            /**
4719            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4720            *
4721            * @param companyId the company ID
4722            * @param status the status
4723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4724            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4725            * @throws SystemException if a system exception occurred
4726            */
4727            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First(
4728                    long companyId, int status,
4729                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4730                    throws com.liferay.portal.kernel.exception.SystemException {
4731                    return getPersistence()
4732                                       .fetchByC_NotST_First(companyId, status, orderByComparator);
4733            }
4734    
4735            /**
4736            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4737            *
4738            * @param companyId the company ID
4739            * @param status the status
4740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4741            * @return the last matching journal article
4742            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4743            * @throws SystemException if a system exception occurred
4744            */
4745            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last(
4746                    long companyId, int status,
4747                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4748                    throws com.liferay.portal.kernel.exception.SystemException,
4749                            com.liferay.portlet.journal.NoSuchArticleException {
4750                    return getPersistence()
4751                                       .findByC_NotST_Last(companyId, status, orderByComparator);
4752            }
4753    
4754            /**
4755            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4756            *
4757            * @param companyId the company ID
4758            * @param status the status
4759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4760            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4761            * @throws SystemException if a system exception occurred
4762            */
4763            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last(
4764                    long companyId, int status,
4765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4766                    throws com.liferay.portal.kernel.exception.SystemException {
4767                    return getPersistence()
4768                                       .fetchByC_NotST_Last(companyId, status, orderByComparator);
4769            }
4770    
4771            /**
4772            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4773            *
4774            * @param id the primary key of the current journal article
4775            * @param companyId the company ID
4776            * @param status the status
4777            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4778            * @return the previous, current, and next journal article
4779            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4780            * @throws SystemException if a system exception occurred
4781            */
4782            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext(
4783                    long id, long companyId, int status,
4784                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4785                    throws com.liferay.portal.kernel.exception.SystemException,
4786                            com.liferay.portlet.journal.NoSuchArticleException {
4787                    return getPersistence()
4788                                       .findByC_NotST_PrevAndNext(id, companyId, status,
4789                            orderByComparator);
4790            }
4791    
4792            /**
4793            * Removes all the journal articles where companyId = &#63; and status &ne; &#63; from the database.
4794            *
4795            * @param companyId the company ID
4796            * @param status the status
4797            * @throws SystemException if a system exception occurred
4798            */
4799            public static void removeByC_NotST(long companyId, int status)
4800                    throws com.liferay.portal.kernel.exception.SystemException {
4801                    getPersistence().removeByC_NotST(companyId, status);
4802            }
4803    
4804            /**
4805            * Returns the number of journal articles where companyId = &#63; and status &ne; &#63;.
4806            *
4807            * @param companyId the company ID
4808            * @param status the status
4809            * @return the number of matching journal articles
4810            * @throws SystemException if a system exception occurred
4811            */
4812            public static int countByC_NotST(long companyId, int status)
4813                    throws com.liferay.portal.kernel.exception.SystemException {
4814                    return getPersistence().countByC_NotST(companyId, status);
4815            }
4816    
4817            /**
4818            * Returns all the journal articles where displayDate &lt; &#63; and status = &#63;.
4819            *
4820            * @param displayDate the display date
4821            * @param status the status
4822            * @return the matching journal articles
4823            * @throws SystemException if a system exception occurred
4824            */
4825            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
4826                    java.util.Date displayDate, int status)
4827                    throws com.liferay.portal.kernel.exception.SystemException {
4828                    return getPersistence().findByLtD_S(displayDate, status);
4829            }
4830    
4831            /**
4832            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
4833            *
4834            * <p>
4835            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4836            * </p>
4837            *
4838            * @param displayDate the display date
4839            * @param status the status
4840            * @param start the lower bound of the range of journal articles
4841            * @param end the upper bound of the range of journal articles (not inclusive)
4842            * @return the range of matching journal articles
4843            * @throws SystemException if a system exception occurred
4844            */
4845            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
4846                    java.util.Date displayDate, int status, int start, int end)
4847                    throws com.liferay.portal.kernel.exception.SystemException {
4848                    return getPersistence().findByLtD_S(displayDate, status, start, end);
4849            }
4850    
4851            /**
4852            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
4853            *
4854            * <p>
4855            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
4856            * </p>
4857            *
4858            * @param displayDate the display date
4859            * @param status the status
4860            * @param start the lower bound of the range of journal articles
4861            * @param end the upper bound of the range of journal articles (not inclusive)
4862            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4863            * @return the ordered range of matching journal articles
4864            * @throws SystemException if a system exception occurred
4865            */
4866            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
4867                    java.util.Date displayDate, int status, int start, int end,
4868                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4869                    throws com.liferay.portal.kernel.exception.SystemException {
4870                    return getPersistence()
4871                                       .findByLtD_S(displayDate, status, start, end,
4872                            orderByComparator);
4873            }
4874    
4875            /**
4876            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4877            *
4878            * @param displayDate the display date
4879            * @param status the status
4880            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4881            * @return the first matching journal article
4882            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4883            * @throws SystemException if a system exception occurred
4884            */
4885            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First(
4886                    java.util.Date displayDate, int status,
4887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4888                    throws com.liferay.portal.kernel.exception.SystemException,
4889                            com.liferay.portlet.journal.NoSuchArticleException {
4890                    return getPersistence()
4891                                       .findByLtD_S_First(displayDate, status, orderByComparator);
4892            }
4893    
4894            /**
4895            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4896            *
4897            * @param displayDate the display date
4898            * @param status the status
4899            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4900            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4901            * @throws SystemException if a system exception occurred
4902            */
4903            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First(
4904                    java.util.Date displayDate, int status,
4905                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4906                    throws com.liferay.portal.kernel.exception.SystemException {
4907                    return getPersistence()
4908                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
4909            }
4910    
4911            /**
4912            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4913            *
4914            * @param displayDate the display date
4915            * @param status the status
4916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4917            * @return the last matching journal article
4918            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4919            * @throws SystemException if a system exception occurred
4920            */
4921            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last(
4922                    java.util.Date displayDate, int status,
4923                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4924                    throws com.liferay.portal.kernel.exception.SystemException,
4925                            com.liferay.portlet.journal.NoSuchArticleException {
4926                    return getPersistence()
4927                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
4928            }
4929    
4930            /**
4931            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4932            *
4933            * @param displayDate the display date
4934            * @param status the status
4935            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4936            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4937            * @throws SystemException if a system exception occurred
4938            */
4939            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last(
4940                    java.util.Date displayDate, int status,
4941                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4942                    throws com.liferay.portal.kernel.exception.SystemException {
4943                    return getPersistence()
4944                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
4945            }
4946    
4947            /**
4948            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4949            *
4950            * @param id the primary key of the current journal article
4951            * @param displayDate the display date
4952            * @param status the status
4953            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4954            * @return the previous, current, and next journal article
4955            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4956            * @throws SystemException if a system exception occurred
4957            */
4958            public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext(
4959                    long id, java.util.Date displayDate, int status,
4960                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4961                    throws com.liferay.portal.kernel.exception.SystemException,
4962                            com.liferay.portlet.journal.NoSuchArticleException {
4963                    return getPersistence()
4964                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
4965                            orderByComparator);
4966            }
4967    
4968            /**
4969            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
4970            *
4971            * @param displayDate the display date
4972            * @param status the status
4973            * @throws SystemException if a system exception occurred
4974            */
4975            public static void removeByLtD_S(java.util.Date displayDate, int status)
4976                    throws com.liferay.portal.kernel.exception.SystemException {
4977                    getPersistence().removeByLtD_S(displayDate, status);
4978            }
4979    
4980            /**
4981            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
4982            *
4983            * @param displayDate the display date
4984            * @param status the status
4985            * @return the number of matching journal articles
4986            * @throws SystemException if a system exception occurred
4987            */
4988            public static int countByLtD_S(java.util.Date displayDate, int status)
4989                    throws com.liferay.portal.kernel.exception.SystemException {
4990                    return getPersistence().countByLtD_S(displayDate, status);
4991            }
4992    
4993            /**
4994            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4995            *
4996            * @param resourcePrimKey the resource prim key
4997            * @param indexable the indexable
4998            * @param status the status
4999            * @return the matching journal articles
5000            * @throws SystemException if a system exception occurred
5001            */
5002            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5003                    long resourcePrimKey, boolean indexable, int status)
5004                    throws com.liferay.portal.kernel.exception.SystemException {
5005                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
5006            }
5007    
5008            /**
5009            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5010            *
5011            * <p>
5012            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5013            * </p>
5014            *
5015            * @param resourcePrimKey the resource prim key
5016            * @param indexable the indexable
5017            * @param status the status
5018            * @param start the lower bound of the range of journal articles
5019            * @param end the upper bound of the range of journal articles (not inclusive)
5020            * @return the range of matching journal articles
5021            * @throws SystemException if a system exception occurred
5022            */
5023            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5024                    long resourcePrimKey, boolean indexable, int status, int start, int end)
5025                    throws com.liferay.portal.kernel.exception.SystemException {
5026                    return getPersistence()
5027                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
5028            }
5029    
5030            /**
5031            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5032            *
5033            * <p>
5034            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5035            * </p>
5036            *
5037            * @param resourcePrimKey the resource prim key
5038            * @param indexable the indexable
5039            * @param status the status
5040            * @param start the lower bound of the range of journal articles
5041            * @param end the upper bound of the range of journal articles (not inclusive)
5042            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5043            * @return the ordered 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> findByR_I_S(
5047                    long resourcePrimKey, boolean indexable, int status, int start,
5048                    int end,
5049                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5050                    throws com.liferay.portal.kernel.exception.SystemException {
5051                    return getPersistence()
5052                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
5053                            orderByComparator);
5054            }
5055    
5056            /**
5057            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5058            *
5059            * @param resourcePrimKey the resource prim key
5060            * @param indexable the indexable
5061            * @param status the status
5062            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5063            * @return the first matching journal article
5064            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5065            * @throws SystemException if a system exception occurred
5066            */
5067            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First(
5068                    long resourcePrimKey, boolean indexable, int status,
5069                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5070                    throws com.liferay.portal.kernel.exception.SystemException,
5071                            com.liferay.portlet.journal.NoSuchArticleException {
5072                    return getPersistence()
5073                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
5074                            orderByComparator);
5075            }
5076    
5077            /**
5078            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5079            *
5080            * @param resourcePrimKey the resource prim key
5081            * @param indexable the indexable
5082            * @param status the status
5083            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5084            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5085            * @throws SystemException if a system exception occurred
5086            */
5087            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First(
5088                    long resourcePrimKey, boolean indexable, int status,
5089                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5090                    throws com.liferay.portal.kernel.exception.SystemException {
5091                    return getPersistence()
5092                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
5093                            orderByComparator);
5094            }
5095    
5096            /**
5097            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5098            *
5099            * @param resourcePrimKey the resource prim key
5100            * @param indexable the indexable
5101            * @param status the status
5102            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5103            * @return the last matching journal article
5104            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5105            * @throws SystemException if a system exception occurred
5106            */
5107            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last(
5108                    long resourcePrimKey, boolean indexable, int status,
5109                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5110                    throws com.liferay.portal.kernel.exception.SystemException,
5111                            com.liferay.portlet.journal.NoSuchArticleException {
5112                    return getPersistence()
5113                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
5114                            orderByComparator);
5115            }
5116    
5117            /**
5118            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5119            *
5120            * @param resourcePrimKey the resource prim key
5121            * @param indexable the indexable
5122            * @param status the status
5123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5124            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5125            * @throws SystemException if a system exception occurred
5126            */
5127            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last(
5128                    long resourcePrimKey, boolean indexable, int status,
5129                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5130                    throws com.liferay.portal.kernel.exception.SystemException {
5131                    return getPersistence()
5132                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
5133                            orderByComparator);
5134            }
5135    
5136            /**
5137            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5138            *
5139            * @param id the primary key of the current journal article
5140            * @param resourcePrimKey the resource prim key
5141            * @param indexable the indexable
5142            * @param status the status
5143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5144            * @return the previous, current, and next journal article
5145            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5146            * @throws SystemException if a system exception occurred
5147            */
5148            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext(
5149                    long id, long resourcePrimKey, boolean indexable, int status,
5150                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5151                    throws com.liferay.portal.kernel.exception.SystemException,
5152                            com.liferay.portlet.journal.NoSuchArticleException {
5153                    return getPersistence()
5154                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
5155                            status, orderByComparator);
5156            }
5157    
5158            /**
5159            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5160            *
5161            * <p>
5162            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5163            * </p>
5164            *
5165            * @param resourcePrimKey the resource prim key
5166            * @param indexable the indexable
5167            * @param statuses the statuses
5168            * @return the matching journal articles
5169            * @throws SystemException if a system exception occurred
5170            */
5171            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5172                    long resourcePrimKey, boolean indexable, int[] statuses)
5173                    throws com.liferay.portal.kernel.exception.SystemException {
5174                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
5175            }
5176    
5177            /**
5178            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5179            *
5180            * <p>
5181            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5182            * </p>
5183            *
5184            * @param resourcePrimKey the resource prim key
5185            * @param indexable the indexable
5186            * @param statuses the statuses
5187            * @param start the lower bound of the range of journal articles
5188            * @param end the upper bound of the range of journal articles (not inclusive)
5189            * @return the range of matching journal articles
5190            * @throws SystemException if a system exception occurred
5191            */
5192            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5193                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5194                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5195                    return getPersistence()
5196                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
5197            }
5198    
5199            /**
5200            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5201            *
5202            * <p>
5203            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5204            * </p>
5205            *
5206            * @param resourcePrimKey the resource prim key
5207            * @param indexable the indexable
5208            * @param statuses the statuses
5209            * @param start the lower bound of the range of journal articles
5210            * @param end the upper bound of the range of journal articles (not inclusive)
5211            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5212            * @return the ordered range of matching journal articles
5213            * @throws SystemException if a system exception occurred
5214            */
5215            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5216                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5217                    int end,
5218                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5219                    throws com.liferay.portal.kernel.exception.SystemException {
5220                    return getPersistence()
5221                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
5222                            end, orderByComparator);
5223            }
5224    
5225            /**
5226            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
5227            *
5228            * @param resourcePrimKey the resource prim key
5229            * @param indexable the indexable
5230            * @param status the status
5231            * @throws SystemException if a system exception occurred
5232            */
5233            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
5234                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5235                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
5236            }
5237    
5238            /**
5239            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5240            *
5241            * @param resourcePrimKey the resource prim key
5242            * @param indexable the indexable
5243            * @param status the status
5244            * @return the number of matching journal articles
5245            * @throws SystemException if a system exception occurred
5246            */
5247            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5248                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5249                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
5250            }
5251    
5252            /**
5253            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5254            *
5255            * @param resourcePrimKey the resource prim key
5256            * @param indexable the indexable
5257            * @param statuses the statuses
5258            * @return the number of matching journal articles
5259            * @throws SystemException if a system exception occurred
5260            */
5261            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5262                    int[] statuses)
5263                    throws com.liferay.portal.kernel.exception.SystemException {
5264                    return getPersistence()
5265                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
5266            }
5267    
5268            /**
5269            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5270            *
5271            * @param groupId the group ID
5272            * @param folderId the folder ID
5273            * @param status the status
5274            * @return the matching journal articles
5275            * @throws SystemException if a system exception occurred
5276            */
5277            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5278                    long groupId, long folderId, int status)
5279                    throws com.liferay.portal.kernel.exception.SystemException {
5280                    return getPersistence().findByG_F_ST(groupId, folderId, status);
5281            }
5282    
5283            /**
5284            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5285            *
5286            * <p>
5287            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5288            * </p>
5289            *
5290            * @param groupId the group ID
5291            * @param folderId the folder ID
5292            * @param status the status
5293            * @param start the lower bound of the range of journal articles
5294            * @param end the upper bound of the range of journal articles (not inclusive)
5295            * @return the range of matching journal articles
5296            * @throws SystemException if a system exception occurred
5297            */
5298            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5299                    long groupId, long folderId, int status, int start, int end)
5300                    throws com.liferay.portal.kernel.exception.SystemException {
5301                    return getPersistence()
5302                                       .findByG_F_ST(groupId, folderId, status, start, end);
5303            }
5304    
5305            /**
5306            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5307            *
5308            * <p>
5309            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5310            * </p>
5311            *
5312            * @param groupId the group ID
5313            * @param folderId the folder ID
5314            * @param status the status
5315            * @param start the lower bound of the range of journal articles
5316            * @param end the upper bound of the range of journal articles (not inclusive)
5317            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5318            * @return the ordered range of matching journal articles
5319            * @throws SystemException if a system exception occurred
5320            */
5321            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5322                    long groupId, long folderId, int status, int start, int end,
5323                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5324                    throws com.liferay.portal.kernel.exception.SystemException {
5325                    return getPersistence()
5326                                       .findByG_F_ST(groupId, folderId, status, start, end,
5327                            orderByComparator);
5328            }
5329    
5330            /**
5331            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5332            *
5333            * @param groupId the group ID
5334            * @param folderId the folder ID
5335            * @param status the status
5336            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5337            * @return the first matching journal article
5338            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5339            * @throws SystemException if a system exception occurred
5340            */
5341            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
5342                    long groupId, long folderId, int status,
5343                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5344                    throws com.liferay.portal.kernel.exception.SystemException,
5345                            com.liferay.portlet.journal.NoSuchArticleException {
5346                    return getPersistence()
5347                                       .findByG_F_ST_First(groupId, folderId, status,
5348                            orderByComparator);
5349            }
5350    
5351            /**
5352            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5353            *
5354            * @param groupId the group ID
5355            * @param folderId the folder ID
5356            * @param status the status
5357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5358            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5359            * @throws SystemException if a system exception occurred
5360            */
5361            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
5362                    long groupId, long folderId, int status,
5363                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5364                    throws com.liferay.portal.kernel.exception.SystemException {
5365                    return getPersistence()
5366                                       .fetchByG_F_ST_First(groupId, folderId, status,
5367                            orderByComparator);
5368            }
5369    
5370            /**
5371            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5372            *
5373            * @param groupId the group ID
5374            * @param folderId the folder ID
5375            * @param status the status
5376            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5377            * @return the last matching journal article
5378            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5379            * @throws SystemException if a system exception occurred
5380            */
5381            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
5382                    long groupId, long folderId, int status,
5383                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5384                    throws com.liferay.portal.kernel.exception.SystemException,
5385                            com.liferay.portlet.journal.NoSuchArticleException {
5386                    return getPersistence()
5387                                       .findByG_F_ST_Last(groupId, folderId, status,
5388                            orderByComparator);
5389            }
5390    
5391            /**
5392            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5393            *
5394            * @param groupId the group ID
5395            * @param folderId the folder ID
5396            * @param status the status
5397            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5398            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5399            * @throws SystemException if a system exception occurred
5400            */
5401            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
5402                    long groupId, long folderId, int status,
5403                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5404                    throws com.liferay.portal.kernel.exception.SystemException {
5405                    return getPersistence()
5406                                       .fetchByG_F_ST_Last(groupId, folderId, status,
5407                            orderByComparator);
5408            }
5409    
5410            /**
5411            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5412            *
5413            * @param id the primary key of the current journal article
5414            * @param groupId the group ID
5415            * @param folderId the folder ID
5416            * @param status the status
5417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5418            * @return the previous, current, and next journal article
5419            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5420            * @throws SystemException if a system exception occurred
5421            */
5422            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
5423                    long id, long groupId, long folderId, int status,
5424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5425                    throws com.liferay.portal.kernel.exception.SystemException,
5426                            com.liferay.portlet.journal.NoSuchArticleException {
5427                    return getPersistence()
5428                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
5429                            orderByComparator);
5430            }
5431    
5432            /**
5433            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5434            *
5435            * @param groupId the group ID
5436            * @param folderId the folder ID
5437            * @param status the status
5438            * @return the matching journal articles that the user has permission to view
5439            * @throws SystemException if a system exception occurred
5440            */
5441            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5442                    long groupId, long folderId, int status)
5443                    throws com.liferay.portal.kernel.exception.SystemException {
5444                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
5445            }
5446    
5447            /**
5448            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5449            *
5450            * <p>
5451            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5452            * </p>
5453            *
5454            * @param groupId the group ID
5455            * @param folderId the folder ID
5456            * @param status the status
5457            * @param start the lower bound of the range of journal articles
5458            * @param end the upper bound of the range of journal articles (not inclusive)
5459            * @return the range of matching journal articles that the user has permission to view
5460            * @throws SystemException if a system exception occurred
5461            */
5462            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5463                    long groupId, long folderId, int status, int start, int end)
5464                    throws com.liferay.portal.kernel.exception.SystemException {
5465                    return getPersistence()
5466                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
5467            }
5468    
5469            /**
5470            * 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;.
5471            *
5472            * <p>
5473            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5474            * </p>
5475            *
5476            * @param groupId the group ID
5477            * @param folderId the folder ID
5478            * @param status the status
5479            * @param start the lower bound of the range of journal articles
5480            * @param end the upper bound of the range of journal articles (not inclusive)
5481            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5482            * @return the ordered range of matching journal articles that the user has permission to view
5483            * @throws SystemException if a system exception occurred
5484            */
5485            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5486                    long groupId, long folderId, int status, int start, int end,
5487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5488                    throws com.liferay.portal.kernel.exception.SystemException {
5489                    return getPersistence()
5490                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
5491                            orderByComparator);
5492            }
5493    
5494            /**
5495            * 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;.
5496            *
5497            * @param id the primary key of the current journal article
5498            * @param groupId the group ID
5499            * @param folderId the folder ID
5500            * @param status the status
5501            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5502            * @return the previous, current, and next journal article
5503            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5504            * @throws SystemException if a system exception occurred
5505            */
5506            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
5507                    long id, long groupId, long folderId, int status,
5508                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5509                    throws com.liferay.portal.kernel.exception.SystemException,
5510                            com.liferay.portlet.journal.NoSuchArticleException {
5511                    return getPersistence()
5512                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
5513                            status, orderByComparator);
5514            }
5515    
5516            /**
5517            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5518            *
5519            * @param groupId the group ID
5520            * @param folderId the folder ID
5521            * @param statuses the statuses
5522            * @return the matching journal articles that the user has permission to view
5523            * @throws SystemException if a system exception occurred
5524            */
5525            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5526                    long groupId, long folderId, int[] statuses)
5527                    throws com.liferay.portal.kernel.exception.SystemException {
5528                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
5529            }
5530    
5531            /**
5532            * 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;.
5533            *
5534            * <p>
5535            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5536            * </p>
5537            *
5538            * @param groupId the group ID
5539            * @param folderId the folder ID
5540            * @param statuses the statuses
5541            * @param start the lower bound of the range of journal articles
5542            * @param end the upper bound of the range of journal articles (not inclusive)
5543            * @return the range of matching journal articles that the user has permission to view
5544            * @throws SystemException if a system exception occurred
5545            */
5546            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5547                    long groupId, long folderId, int[] statuses, int start, int end)
5548                    throws com.liferay.portal.kernel.exception.SystemException {
5549                    return getPersistence()
5550                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
5551            }
5552    
5553            /**
5554            * 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;.
5555            *
5556            * <p>
5557            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5558            * </p>
5559            *
5560            * @param groupId the group ID
5561            * @param folderId the folder ID
5562            * @param statuses the statuses
5563            * @param start the lower bound of the range of journal articles
5564            * @param end the upper bound of the range of journal articles (not inclusive)
5565            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5566            * @return the ordered range of matching journal articles that the user has permission to view
5567            * @throws SystemException if a system exception occurred
5568            */
5569            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5570                    long groupId, long folderId, int[] statuses, int start, int end,
5571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5572                    throws com.liferay.portal.kernel.exception.SystemException {
5573                    return getPersistence()
5574                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
5575                            orderByComparator);
5576            }
5577    
5578            /**
5579            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5580            *
5581            * <p>
5582            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5583            * </p>
5584            *
5585            * @param groupId the group ID
5586            * @param folderId the folder ID
5587            * @param statuses the statuses
5588            * @return the matching journal articles
5589            * @throws SystemException if a system exception occurred
5590            */
5591            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5592                    long groupId, long folderId, int[] statuses)
5593                    throws com.liferay.portal.kernel.exception.SystemException {
5594                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
5595            }
5596    
5597            /**
5598            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5599            *
5600            * <p>
5601            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5602            * </p>
5603            *
5604            * @param groupId the group ID
5605            * @param folderId the folder ID
5606            * @param statuses the statuses
5607            * @param start the lower bound of the range of journal articles
5608            * @param end the upper bound of the range of journal articles (not inclusive)
5609            * @return the range of matching journal articles
5610            * @throws SystemException if a system exception occurred
5611            */
5612            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5613                    long groupId, long folderId, int[] statuses, int start, int end)
5614                    throws com.liferay.portal.kernel.exception.SystemException {
5615                    return getPersistence()
5616                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
5617            }
5618    
5619            /**
5620            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5621            *
5622            * <p>
5623            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5624            * </p>
5625            *
5626            * @param groupId the group ID
5627            * @param folderId the folder ID
5628            * @param statuses the statuses
5629            * @param start the lower bound of the range of journal articles
5630            * @param end the upper bound of the range of journal articles (not inclusive)
5631            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5632            * @return the ordered range of matching journal articles
5633            * @throws SystemException if a system exception occurred
5634            */
5635            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5636                    long groupId, long folderId, int[] statuses, int start, int end,
5637                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5638                    throws com.liferay.portal.kernel.exception.SystemException {
5639                    return getPersistence()
5640                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
5641                            orderByComparator);
5642            }
5643    
5644            /**
5645            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
5646            *
5647            * @param groupId the group ID
5648            * @param folderId the folder ID
5649            * @param status the status
5650            * @throws SystemException if a system exception occurred
5651            */
5652            public static void removeByG_F_ST(long groupId, long folderId, int status)
5653                    throws com.liferay.portal.kernel.exception.SystemException {
5654                    getPersistence().removeByG_F_ST(groupId, folderId, status);
5655            }
5656    
5657            /**
5658            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5659            *
5660            * @param groupId the group ID
5661            * @param folderId the folder ID
5662            * @param status the status
5663            * @return the number of matching journal articles
5664            * @throws SystemException if a system exception occurred
5665            */
5666            public static int countByG_F_ST(long groupId, long folderId, int status)
5667                    throws com.liferay.portal.kernel.exception.SystemException {
5668                    return getPersistence().countByG_F_ST(groupId, folderId, status);
5669            }
5670    
5671            /**
5672            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5673            *
5674            * @param groupId the group ID
5675            * @param folderId the folder ID
5676            * @param statuses the statuses
5677            * @return the number of matching journal articles
5678            * @throws SystemException if a system exception occurred
5679            */
5680            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
5681                    throws com.liferay.portal.kernel.exception.SystemException {
5682                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
5683            }
5684    
5685            /**
5686            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5687            *
5688            * @param groupId the group ID
5689            * @param folderId the folder ID
5690            * @param status the status
5691            * @return the number of matching journal articles that the user has permission to view
5692            * @throws SystemException if a system exception occurred
5693            */
5694            public static int filterCountByG_F_ST(long groupId, long folderId,
5695                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5696                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
5697            }
5698    
5699            /**
5700            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5701            *
5702            * @param groupId the group ID
5703            * @param folderId the folder ID
5704            * @param statuses the statuses
5705            * @return the number of matching journal articles that the user has permission to view
5706            * @throws SystemException if a system exception occurred
5707            */
5708            public static int filterCountByG_F_ST(long groupId, long folderId,
5709                    int[] statuses)
5710                    throws com.liferay.portal.kernel.exception.SystemException {
5711                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
5712            }
5713    
5714            /**
5715            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5716            *
5717            * @param groupId the group ID
5718            * @param classNameId the class name ID
5719            * @param classPK the class p k
5720            * @return the matching journal articles
5721            * @throws SystemException if a system exception occurred
5722            */
5723            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5724                    long groupId, long classNameId, long classPK)
5725                    throws com.liferay.portal.kernel.exception.SystemException {
5726                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5727            }
5728    
5729            /**
5730            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5731            *
5732            * <p>
5733            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5734            * </p>
5735            *
5736            * @param groupId the group ID
5737            * @param classNameId the class name ID
5738            * @param classPK the class p k
5739            * @param start the lower bound of the range of journal articles
5740            * @param end the upper bound of the range of journal articles (not inclusive)
5741            * @return the range of matching journal articles
5742            * @throws SystemException if a system exception occurred
5743            */
5744            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5745                    long groupId, long classNameId, long classPK, int start, int end)
5746                    throws com.liferay.portal.kernel.exception.SystemException {
5747                    return getPersistence()
5748                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5749            }
5750    
5751            /**
5752            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5753            *
5754            * <p>
5755            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5756            * </p>
5757            *
5758            * @param groupId the group ID
5759            * @param classNameId the class name ID
5760            * @param classPK the class p k
5761            * @param start the lower bound of the range of journal articles
5762            * @param end the upper bound of the range of journal articles (not inclusive)
5763            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5764            * @return the ordered range of matching journal articles
5765            * @throws SystemException if a system exception occurred
5766            */
5767            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5768                    long groupId, long classNameId, long classPK, int start, int end,
5769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5770                    throws com.liferay.portal.kernel.exception.SystemException {
5771                    return getPersistence()
5772                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
5773                            orderByComparator);
5774            }
5775    
5776            /**
5777            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5778            *
5779            * @param groupId the group ID
5780            * @param classNameId the class name ID
5781            * @param classPK the class p k
5782            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5783            * @return the first matching journal article
5784            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5785            * @throws SystemException if a system exception occurred
5786            */
5787            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
5788                    long groupId, long classNameId, long classPK,
5789                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5790                    throws com.liferay.portal.kernel.exception.SystemException,
5791                            com.liferay.portlet.journal.NoSuchArticleException {
5792                    return getPersistence()
5793                                       .findByG_C_C_First(groupId, classNameId, classPK,
5794                            orderByComparator);
5795            }
5796    
5797            /**
5798            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5799            *
5800            * @param groupId the group ID
5801            * @param classNameId the class name ID
5802            * @param classPK the class p k
5803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5804            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5805            * @throws SystemException if a system exception occurred
5806            */
5807            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
5808                    long groupId, long classNameId, long classPK,
5809                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5810                    throws com.liferay.portal.kernel.exception.SystemException {
5811                    return getPersistence()
5812                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5813                            orderByComparator);
5814            }
5815    
5816            /**
5817            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5818            *
5819            * @param groupId the group ID
5820            * @param classNameId the class name ID
5821            * @param classPK the class p k
5822            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5823            * @return the last matching journal article
5824            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5825            * @throws SystemException if a system exception occurred
5826            */
5827            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
5828                    long groupId, long classNameId, long classPK,
5829                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5830                    throws com.liferay.portal.kernel.exception.SystemException,
5831                            com.liferay.portlet.journal.NoSuchArticleException {
5832                    return getPersistence()
5833                                       .findByG_C_C_Last(groupId, classNameId, classPK,
5834                            orderByComparator);
5835            }
5836    
5837            /**
5838            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5839            *
5840            * @param groupId the group ID
5841            * @param classNameId the class name ID
5842            * @param classPK the class p k
5843            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5844            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5845            * @throws SystemException if a system exception occurred
5846            */
5847            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
5848                    long groupId, long classNameId, long classPK,
5849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5850                    throws com.liferay.portal.kernel.exception.SystemException {
5851                    return getPersistence()
5852                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
5853                            orderByComparator);
5854            }
5855    
5856            /**
5857            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5858            *
5859            * @param id the primary key of the current journal article
5860            * @param groupId the group ID
5861            * @param classNameId the class name ID
5862            * @param classPK the class p k
5863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5864            * @return the previous, current, and next journal article
5865            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5866            * @throws SystemException if a system exception occurred
5867            */
5868            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
5869                    long id, long groupId, long classNameId, long classPK,
5870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5871                    throws com.liferay.portal.kernel.exception.SystemException,
5872                            com.liferay.portlet.journal.NoSuchArticleException {
5873                    return getPersistence()
5874                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5875                            orderByComparator);
5876            }
5877    
5878            /**
5879            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5880            *
5881            * @param groupId the group ID
5882            * @param classNameId the class name ID
5883            * @param classPK the class p k
5884            * @return the matching journal articles that the user has permission to view
5885            * @throws SystemException if a system exception occurred
5886            */
5887            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5888                    long groupId, long classNameId, long classPK)
5889                    throws com.liferay.portal.kernel.exception.SystemException {
5890                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5891            }
5892    
5893            /**
5894            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5895            *
5896            * <p>
5897            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5898            * </p>
5899            *
5900            * @param groupId the group ID
5901            * @param classNameId the class name ID
5902            * @param classPK the class p k
5903            * @param start the lower bound of the range of journal articles
5904            * @param end the upper bound of the range of journal articles (not inclusive)
5905            * @return the range of matching journal articles that the user has permission to view
5906            * @throws SystemException if a system exception occurred
5907            */
5908            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5909                    long groupId, long classNameId, long classPK, int start, int end)
5910                    throws com.liferay.portal.kernel.exception.SystemException {
5911                    return getPersistence()
5912                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
5913            }
5914    
5915            /**
5916            * 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;.
5917            *
5918            * <p>
5919            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
5920            * </p>
5921            *
5922            * @param groupId the group ID
5923            * @param classNameId the class name ID
5924            * @param classPK the class p k
5925            * @param start the lower bound of the range of journal articles
5926            * @param end the upper bound of the range of journal articles (not inclusive)
5927            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5928            * @return the ordered range of matching journal articles that the user has permission to view
5929            * @throws SystemException if a system exception occurred
5930            */
5931            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5932                    long groupId, long classNameId, long classPK, int start, int end,
5933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5934                    throws com.liferay.portal.kernel.exception.SystemException {
5935                    return getPersistence()
5936                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
5937                            end, orderByComparator);
5938            }
5939    
5940            /**
5941            * 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;.
5942            *
5943            * @param id the primary key of the current journal article
5944            * @param groupId the group ID
5945            * @param classNameId the class name ID
5946            * @param classPK the class p k
5947            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5948            * @return the previous, current, and next journal article
5949            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5950            * @throws SystemException if a system exception occurred
5951            */
5952            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
5953                    long id, long groupId, long classNameId, long classPK,
5954                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5955                    throws com.liferay.portal.kernel.exception.SystemException,
5956                            com.liferay.portlet.journal.NoSuchArticleException {
5957                    return getPersistence()
5958                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
5959                            classPK, orderByComparator);
5960            }
5961    
5962            /**
5963            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5964            *
5965            * @param groupId the group ID
5966            * @param classNameId the class name ID
5967            * @param classPK the class p k
5968            * @throws SystemException if a system exception occurred
5969            */
5970            public static void removeByG_C_C(long groupId, long classNameId,
5971                    long classPK)
5972                    throws com.liferay.portal.kernel.exception.SystemException {
5973                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5974            }
5975    
5976            /**
5977            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5978            *
5979            * @param groupId the group ID
5980            * @param classNameId the class name ID
5981            * @param classPK the class p k
5982            * @return the number of matching journal articles
5983            * @throws SystemException if a system exception occurred
5984            */
5985            public static int countByG_C_C(long groupId, long classNameId, long classPK)
5986                    throws com.liferay.portal.kernel.exception.SystemException {
5987                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5988            }
5989    
5990            /**
5991            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5992            *
5993            * @param groupId the group ID
5994            * @param classNameId the class name ID
5995            * @param classPK the class p k
5996            * @return the number of matching journal articles that the user has permission to view
5997            * @throws SystemException if a system exception occurred
5998            */
5999            public static int filterCountByG_C_C(long groupId, long classNameId,
6000                    long classPK)
6001                    throws com.liferay.portal.kernel.exception.SystemException {
6002                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
6003            }
6004    
6005            /**
6006            * 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.
6007            *
6008            * @param groupId the group ID
6009            * @param classNameId the class name ID
6010            * @param structureId the structure ID
6011            * @return the matching journal article
6012            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6013            * @throws SystemException if a system exception occurred
6014            */
6015            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
6016                    long groupId, long classNameId, java.lang.String structureId)
6017                    throws com.liferay.portal.kernel.exception.SystemException,
6018                            com.liferay.portlet.journal.NoSuchArticleException {
6019                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
6020            }
6021    
6022            /**
6023            * 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.
6024            *
6025            * @param groupId the group ID
6026            * @param classNameId the class name ID
6027            * @param structureId the structure ID
6028            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6029            * @throws SystemException if a system exception occurred
6030            */
6031            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6032                    long groupId, long classNameId, java.lang.String structureId)
6033                    throws com.liferay.portal.kernel.exception.SystemException {
6034                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
6035            }
6036    
6037            /**
6038            * 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.
6039            *
6040            * @param groupId the group ID
6041            * @param classNameId the class name ID
6042            * @param structureId the structure ID
6043            * @param retrieveFromCache whether to use the finder cache
6044            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6045            * @throws SystemException if a system exception occurred
6046            */
6047            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6048                    long groupId, long classNameId, java.lang.String structureId,
6049                    boolean retrieveFromCache)
6050                    throws com.liferay.portal.kernel.exception.SystemException {
6051                    return getPersistence()
6052                                       .fetchByG_C_S(groupId, classNameId, structureId,
6053                            retrieveFromCache);
6054            }
6055    
6056            /**
6057            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
6058            *
6059            * @param groupId the group ID
6060            * @param classNameId the class name ID
6061            * @param structureId the structure ID
6062            * @return the journal article that was removed
6063            * @throws SystemException if a system exception occurred
6064            */
6065            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
6066                    long groupId, long classNameId, java.lang.String structureId)
6067                    throws com.liferay.portal.kernel.exception.SystemException,
6068                            com.liferay.portlet.journal.NoSuchArticleException {
6069                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
6070            }
6071    
6072            /**
6073            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
6074            *
6075            * @param groupId the group ID
6076            * @param classNameId the class name ID
6077            * @param structureId the structure ID
6078            * @return the number of matching journal articles
6079            * @throws SystemException if a system exception occurred
6080            */
6081            public static int countByG_C_S(long groupId, long classNameId,
6082                    java.lang.String structureId)
6083                    throws com.liferay.portal.kernel.exception.SystemException {
6084                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
6085            }
6086    
6087            /**
6088            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6089            *
6090            * @param groupId the group ID
6091            * @param classNameId the class name ID
6092            * @param templateId the template ID
6093            * @return the matching journal articles
6094            * @throws SystemException if a system exception occurred
6095            */
6096            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6097                    long groupId, long classNameId, java.lang.String templateId)
6098                    throws com.liferay.portal.kernel.exception.SystemException {
6099                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
6100            }
6101    
6102            /**
6103            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6104            *
6105            * <p>
6106            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6107            * </p>
6108            *
6109            * @param groupId the group ID
6110            * @param classNameId the class name ID
6111            * @param templateId the template ID
6112            * @param start the lower bound of the range of journal articles
6113            * @param end the upper bound of the range of journal articles (not inclusive)
6114            * @return the range of matching journal articles
6115            * @throws SystemException if a system exception occurred
6116            */
6117            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6118                    long groupId, long classNameId, java.lang.String templateId, int start,
6119                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6120                    return getPersistence()
6121                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
6122            }
6123    
6124            /**
6125            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6126            *
6127            * <p>
6128            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6129            * </p>
6130            *
6131            * @param groupId the group ID
6132            * @param classNameId the class name ID
6133            * @param templateId the template ID
6134            * @param start the lower bound of the range of journal articles
6135            * @param end the upper bound of the range of journal articles (not inclusive)
6136            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6137            * @return the ordered range of matching journal articles
6138            * @throws SystemException if a system exception occurred
6139            */
6140            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6141                    long groupId, long classNameId, java.lang.String templateId, int start,
6142                    int end,
6143                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6144                    throws com.liferay.portal.kernel.exception.SystemException {
6145                    return getPersistence()
6146                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
6147                            orderByComparator);
6148            }
6149    
6150            /**
6151            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6152            *
6153            * @param groupId the group ID
6154            * @param classNameId the class name ID
6155            * @param templateId the template ID
6156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6157            * @return the first matching journal article
6158            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6159            * @throws SystemException if a system exception occurred
6160            */
6161            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
6162                    long groupId, long classNameId, java.lang.String templateId,
6163                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6164                    throws com.liferay.portal.kernel.exception.SystemException,
6165                            com.liferay.portlet.journal.NoSuchArticleException {
6166                    return getPersistence()
6167                                       .findByG_C_T_First(groupId, classNameId, templateId,
6168                            orderByComparator);
6169            }
6170    
6171            /**
6172            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6173            *
6174            * @param groupId the group ID
6175            * @param classNameId the class name ID
6176            * @param templateId the template ID
6177            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6178            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6179            * @throws SystemException if a system exception occurred
6180            */
6181            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
6182                    long groupId, long classNameId, java.lang.String templateId,
6183                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6184                    throws com.liferay.portal.kernel.exception.SystemException {
6185                    return getPersistence()
6186                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
6187                            orderByComparator);
6188            }
6189    
6190            /**
6191            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6192            *
6193            * @param groupId the group ID
6194            * @param classNameId the class name ID
6195            * @param templateId the template ID
6196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6197            * @return the last matching journal article
6198            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6199            * @throws SystemException if a system exception occurred
6200            */
6201            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
6202                    long groupId, long classNameId, java.lang.String templateId,
6203                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6204                    throws com.liferay.portal.kernel.exception.SystemException,
6205                            com.liferay.portlet.journal.NoSuchArticleException {
6206                    return getPersistence()
6207                                       .findByG_C_T_Last(groupId, classNameId, templateId,
6208                            orderByComparator);
6209            }
6210    
6211            /**
6212            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6213            *
6214            * @param groupId the group ID
6215            * @param classNameId the class name ID
6216            * @param templateId the template ID
6217            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6218            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6219            * @throws SystemException if a system exception occurred
6220            */
6221            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
6222                    long groupId, long classNameId, java.lang.String templateId,
6223                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6224                    throws com.liferay.portal.kernel.exception.SystemException {
6225                    return getPersistence()
6226                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
6227                            orderByComparator);
6228            }
6229    
6230            /**
6231            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6232            *
6233            * @param id the primary key of the current journal article
6234            * @param groupId the group ID
6235            * @param classNameId the class name ID
6236            * @param templateId the template ID
6237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6238            * @return the previous, current, and next journal article
6239            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6240            * @throws SystemException if a system exception occurred
6241            */
6242            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
6243                    long id, long groupId, long classNameId, java.lang.String templateId,
6244                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6245                    throws com.liferay.portal.kernel.exception.SystemException,
6246                            com.liferay.portlet.journal.NoSuchArticleException {
6247                    return getPersistence()
6248                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
6249                            templateId, orderByComparator);
6250            }
6251    
6252            /**
6253            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6254            *
6255            * @param groupId the group ID
6256            * @param classNameId the class name ID
6257            * @param templateId the template ID
6258            * @return the matching journal articles that the user has permission to view
6259            * @throws SystemException if a system exception occurred
6260            */
6261            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6262                    long groupId, long classNameId, java.lang.String templateId)
6263                    throws com.liferay.portal.kernel.exception.SystemException {
6264                    return getPersistence()
6265                                       .filterFindByG_C_T(groupId, classNameId, templateId);
6266            }
6267    
6268            /**
6269            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6270            *
6271            * <p>
6272            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6273            * </p>
6274            *
6275            * @param groupId the group ID
6276            * @param classNameId the class name ID
6277            * @param templateId the template ID
6278            * @param start the lower bound of the range of journal articles
6279            * @param end the upper bound of the range of journal articles (not inclusive)
6280            * @return the range of matching journal articles that the user has permission to view
6281            * @throws SystemException if a system exception occurred
6282            */
6283            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6284                    long groupId, long classNameId, java.lang.String templateId, int start,
6285                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6286                    return getPersistence()
6287                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6288                            end);
6289            }
6290    
6291            /**
6292            * 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;.
6293            *
6294            * <p>
6295            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6296            * </p>
6297            *
6298            * @param groupId the group ID
6299            * @param classNameId the class name ID
6300            * @param templateId the template ID
6301            * @param start the lower bound of the range of journal articles
6302            * @param end the upper bound of the range of journal articles (not inclusive)
6303            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6304            * @return the ordered range of matching journal articles that the user has permission to view
6305            * @throws SystemException if a system exception occurred
6306            */
6307            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6308                    long groupId, long classNameId, java.lang.String templateId, int start,
6309                    int end,
6310                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6311                    throws com.liferay.portal.kernel.exception.SystemException {
6312                    return getPersistence()
6313                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6314                            end, orderByComparator);
6315            }
6316    
6317            /**
6318            * 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;.
6319            *
6320            * @param id the primary key of the current journal article
6321            * @param groupId the group ID
6322            * @param classNameId the class name ID
6323            * @param templateId the template ID
6324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6325            * @return the previous, current, and next journal article
6326            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6327            * @throws SystemException if a system exception occurred
6328            */
6329            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
6330                    long id, long groupId, long classNameId, java.lang.String templateId,
6331                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6332                    throws com.liferay.portal.kernel.exception.SystemException,
6333                            com.liferay.portlet.journal.NoSuchArticleException {
6334                    return getPersistence()
6335                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
6336                            templateId, orderByComparator);
6337            }
6338    
6339            /**
6340            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
6341            *
6342            * @param groupId the group ID
6343            * @param classNameId the class name ID
6344            * @param templateId the template ID
6345            * @throws SystemException if a system exception occurred
6346            */
6347            public static void removeByG_C_T(long groupId, long classNameId,
6348                    java.lang.String templateId)
6349                    throws com.liferay.portal.kernel.exception.SystemException {
6350                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
6351            }
6352    
6353            /**
6354            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6355            *
6356            * @param groupId the group ID
6357            * @param classNameId the class name ID
6358            * @param templateId the template ID
6359            * @return the number of matching journal articles
6360            * @throws SystemException if a system exception occurred
6361            */
6362            public static int countByG_C_T(long groupId, long classNameId,
6363                    java.lang.String templateId)
6364                    throws com.liferay.portal.kernel.exception.SystemException {
6365                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
6366            }
6367    
6368            /**
6369            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6370            *
6371            * @param groupId the group ID
6372            * @param classNameId the class name ID
6373            * @param templateId the template ID
6374            * @return the number of matching journal articles that the user has permission to view
6375            * @throws SystemException if a system exception occurred
6376            */
6377            public static int filterCountByG_C_T(long groupId, long classNameId,
6378                    java.lang.String templateId)
6379                    throws com.liferay.portal.kernel.exception.SystemException {
6380                    return getPersistence()
6381                                       .filterCountByG_C_T(groupId, classNameId, templateId);
6382            }
6383    
6384            /**
6385            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6386            *
6387            * @param groupId the group ID
6388            * @param classNameId the class name ID
6389            * @param layoutUuid the layout uuid
6390            * @return the matching journal articles
6391            * @throws SystemException if a system exception occurred
6392            */
6393            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6394                    long groupId, long classNameId, java.lang.String layoutUuid)
6395                    throws com.liferay.portal.kernel.exception.SystemException {
6396                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
6397            }
6398    
6399            /**
6400            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6401            *
6402            * <p>
6403            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6404            * </p>
6405            *
6406            * @param groupId the group ID
6407            * @param classNameId the class name ID
6408            * @param layoutUuid the layout uuid
6409            * @param start the lower bound of the range of journal articles
6410            * @param end the upper bound of the range of journal articles (not inclusive)
6411            * @return the range of matching journal articles
6412            * @throws SystemException if a system exception occurred
6413            */
6414            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6415                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6416                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6417                    return getPersistence()
6418                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6419            }
6420    
6421            /**
6422            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6423            *
6424            * <p>
6425            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6426            * </p>
6427            *
6428            * @param groupId the group ID
6429            * @param classNameId the class name ID
6430            * @param layoutUuid the layout uuid
6431            * @param start the lower bound of the range of journal articles
6432            * @param end the upper bound of the range of journal articles (not inclusive)
6433            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6434            * @return the ordered range of matching journal articles
6435            * @throws SystemException if a system exception occurred
6436            */
6437            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6438                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6439                    int end,
6440                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6441                    throws com.liferay.portal.kernel.exception.SystemException {
6442                    return getPersistence()
6443                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6444                            orderByComparator);
6445            }
6446    
6447            /**
6448            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6449            *
6450            * @param groupId the group ID
6451            * @param classNameId the class name ID
6452            * @param layoutUuid the layout uuid
6453            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6454            * @return the first matching journal article
6455            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6456            * @throws SystemException if a system exception occurred
6457            */
6458            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
6459                    long groupId, long classNameId, java.lang.String layoutUuid,
6460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6461                    throws com.liferay.portal.kernel.exception.SystemException,
6462                            com.liferay.portlet.journal.NoSuchArticleException {
6463                    return getPersistence()
6464                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
6465                            orderByComparator);
6466            }
6467    
6468            /**
6469            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6470            *
6471            * @param groupId the group ID
6472            * @param classNameId the class name ID
6473            * @param layoutUuid the layout uuid
6474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6475            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6476            * @throws SystemException if a system exception occurred
6477            */
6478            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
6479                    long groupId, long classNameId, java.lang.String layoutUuid,
6480                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6481                    throws com.liferay.portal.kernel.exception.SystemException {
6482                    return getPersistence()
6483                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
6484                            orderByComparator);
6485            }
6486    
6487            /**
6488            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6489            *
6490            * @param groupId the group ID
6491            * @param classNameId the class name ID
6492            * @param layoutUuid the layout uuid
6493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6494            * @return the last matching journal article
6495            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6496            * @throws SystemException if a system exception occurred
6497            */
6498            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
6499                    long groupId, long classNameId, java.lang.String layoutUuid,
6500                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6501                    throws com.liferay.portal.kernel.exception.SystemException,
6502                            com.liferay.portlet.journal.NoSuchArticleException {
6503                    return getPersistence()
6504                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
6505                            orderByComparator);
6506            }
6507    
6508            /**
6509            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6510            *
6511            * @param groupId the group ID
6512            * @param classNameId the class name ID
6513            * @param layoutUuid the layout uuid
6514            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6515            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6516            * @throws SystemException if a system exception occurred
6517            */
6518            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
6519                    long groupId, long classNameId, java.lang.String layoutUuid,
6520                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6521                    throws com.liferay.portal.kernel.exception.SystemException {
6522                    return getPersistence()
6523                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
6524                            orderByComparator);
6525            }
6526    
6527            /**
6528            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6529            *
6530            * @param id the primary key of the current journal article
6531            * @param groupId the group ID
6532            * @param classNameId the class name ID
6533            * @param layoutUuid the layout uuid
6534            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6535            * @return the previous, current, and next journal article
6536            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6537            * @throws SystemException if a system exception occurred
6538            */
6539            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
6540                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6542                    throws com.liferay.portal.kernel.exception.SystemException,
6543                            com.liferay.portlet.journal.NoSuchArticleException {
6544                    return getPersistence()
6545                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
6546                            layoutUuid, orderByComparator);
6547            }
6548    
6549            /**
6550            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6551            *
6552            * @param groupId the group ID
6553            * @param classNameId the class name ID
6554            * @param layoutUuid the layout uuid
6555            * @return the matching journal articles that the user has permission to view
6556            * @throws SystemException if a system exception occurred
6557            */
6558            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6559                    long groupId, long classNameId, java.lang.String layoutUuid)
6560                    throws com.liferay.portal.kernel.exception.SystemException {
6561                    return getPersistence()
6562                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
6563            }
6564    
6565            /**
6566            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6567            *
6568            * <p>
6569            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6570            * </p>
6571            *
6572            * @param groupId the group ID
6573            * @param classNameId the class name ID
6574            * @param layoutUuid the layout uuid
6575            * @param start the lower bound of the range of journal articles
6576            * @param end the upper bound of the range of journal articles (not inclusive)
6577            * @return the range of matching journal articles that the user has permission to view
6578            * @throws SystemException if a system exception occurred
6579            */
6580            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6581                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6582                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6583                    return getPersistence()
6584                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6585                            end);
6586            }
6587    
6588            /**
6589            * 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;.
6590            *
6591            * <p>
6592            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6593            * </p>
6594            *
6595            * @param groupId the group ID
6596            * @param classNameId the class name ID
6597            * @param layoutUuid the layout uuid
6598            * @param start the lower bound of the range of journal articles
6599            * @param end the upper bound of the range of journal articles (not inclusive)
6600            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6601            * @return the ordered range of matching journal articles that the user has permission to view
6602            * @throws SystemException if a system exception occurred
6603            */
6604            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6605                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6606                    int end,
6607                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6608                    throws com.liferay.portal.kernel.exception.SystemException {
6609                    return getPersistence()
6610                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6611                            end, orderByComparator);
6612            }
6613    
6614            /**
6615            * 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;.
6616            *
6617            * @param id the primary key of the current journal article
6618            * @param groupId the group ID
6619            * @param classNameId the class name ID
6620            * @param layoutUuid the layout uuid
6621            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6622            * @return the previous, current, and next journal article
6623            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6624            * @throws SystemException if a system exception occurred
6625            */
6626            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
6627                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6628                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6629                    throws com.liferay.portal.kernel.exception.SystemException,
6630                            com.liferay.portlet.journal.NoSuchArticleException {
6631                    return getPersistence()
6632                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6633                            layoutUuid, orderByComparator);
6634            }
6635    
6636            /**
6637            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6638            *
6639            * @param groupId the group ID
6640            * @param classNameId the class name ID
6641            * @param layoutUuid the layout uuid
6642            * @throws SystemException if a system exception occurred
6643            */
6644            public static void removeByG_C_L(long groupId, long classNameId,
6645                    java.lang.String layoutUuid)
6646                    throws com.liferay.portal.kernel.exception.SystemException {
6647                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6648            }
6649    
6650            /**
6651            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6652            *
6653            * @param groupId the group ID
6654            * @param classNameId the class name ID
6655            * @param layoutUuid the layout uuid
6656            * @return the number of matching journal articles
6657            * @throws SystemException if a system exception occurred
6658            */
6659            public static int countByG_C_L(long groupId, long classNameId,
6660                    java.lang.String layoutUuid)
6661                    throws com.liferay.portal.kernel.exception.SystemException {
6662                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6663            }
6664    
6665            /**
6666            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6667            *
6668            * @param groupId the group ID
6669            * @param classNameId the class name ID
6670            * @param layoutUuid the layout uuid
6671            * @return the number of matching journal articles that the user has permission to view
6672            * @throws SystemException if a system exception occurred
6673            */
6674            public static int filterCountByG_C_L(long groupId, long classNameId,
6675                    java.lang.String layoutUuid)
6676                    throws com.liferay.portal.kernel.exception.SystemException {
6677                    return getPersistence()
6678                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
6679            }
6680    
6681            /**
6682            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6683            *
6684            * @param groupId the group ID
6685            * @param userId the user ID
6686            * @param classNameId the class name ID
6687            * @return the matching journal articles
6688            * @throws SystemException if a system exception occurred
6689            */
6690            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6691                    long groupId, long userId, long classNameId)
6692                    throws com.liferay.portal.kernel.exception.SystemException {
6693                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
6694            }
6695    
6696            /**
6697            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6698            *
6699            * <p>
6700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6701            * </p>
6702            *
6703            * @param groupId the group ID
6704            * @param userId the user ID
6705            * @param classNameId the class name ID
6706            * @param start the lower bound of the range of journal articles
6707            * @param end the upper bound of the range of journal articles (not inclusive)
6708            * @return the range of matching journal articles
6709            * @throws SystemException if a system exception occurred
6710            */
6711            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6712                    long groupId, long userId, long classNameId, int start, int end)
6713                    throws com.liferay.portal.kernel.exception.SystemException {
6714                    return getPersistence()
6715                                       .findByG_U_C(groupId, userId, classNameId, start, end);
6716            }
6717    
6718            /**
6719            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6720            *
6721            * <p>
6722            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6723            * </p>
6724            *
6725            * @param groupId the group ID
6726            * @param userId the user ID
6727            * @param classNameId the class name ID
6728            * @param start the lower bound of the range of journal articles
6729            * @param end the upper bound of the range of journal articles (not inclusive)
6730            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6731            * @return the ordered range of matching journal articles
6732            * @throws SystemException if a system exception occurred
6733            */
6734            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6735                    long groupId, long userId, long classNameId, int start, int end,
6736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6737                    throws com.liferay.portal.kernel.exception.SystemException {
6738                    return getPersistence()
6739                                       .findByG_U_C(groupId, userId, classNameId, start, end,
6740                            orderByComparator);
6741            }
6742    
6743            /**
6744            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6745            *
6746            * @param groupId the group ID
6747            * @param userId the user ID
6748            * @param classNameId the class name ID
6749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6750            * @return the first matching journal article
6751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6752            * @throws SystemException if a system exception occurred
6753            */
6754            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
6755                    long groupId, long userId, long classNameId,
6756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6757                    throws com.liferay.portal.kernel.exception.SystemException,
6758                            com.liferay.portlet.journal.NoSuchArticleException {
6759                    return getPersistence()
6760                                       .findByG_U_C_First(groupId, userId, classNameId,
6761                            orderByComparator);
6762            }
6763    
6764            /**
6765            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6766            *
6767            * @param groupId the group ID
6768            * @param userId the user ID
6769            * @param classNameId the class name ID
6770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6771            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6772            * @throws SystemException if a system exception occurred
6773            */
6774            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
6775                    long groupId, long userId, long classNameId,
6776                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6777                    throws com.liferay.portal.kernel.exception.SystemException {
6778                    return getPersistence()
6779                                       .fetchByG_U_C_First(groupId, userId, classNameId,
6780                            orderByComparator);
6781            }
6782    
6783            /**
6784            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6785            *
6786            * @param groupId the group ID
6787            * @param userId the user ID
6788            * @param classNameId the class name ID
6789            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6790            * @return the last matching journal article
6791            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6792            * @throws SystemException if a system exception occurred
6793            */
6794            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
6795                    long groupId, long userId, long classNameId,
6796                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6797                    throws com.liferay.portal.kernel.exception.SystemException,
6798                            com.liferay.portlet.journal.NoSuchArticleException {
6799                    return getPersistence()
6800                                       .findByG_U_C_Last(groupId, userId, classNameId,
6801                            orderByComparator);
6802            }
6803    
6804            /**
6805            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6806            *
6807            * @param groupId the group ID
6808            * @param userId the user ID
6809            * @param classNameId the class name ID
6810            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6811            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6812            * @throws SystemException if a system exception occurred
6813            */
6814            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
6815                    long groupId, long userId, long classNameId,
6816                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6817                    throws com.liferay.portal.kernel.exception.SystemException {
6818                    return getPersistence()
6819                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
6820                            orderByComparator);
6821            }
6822    
6823            /**
6824            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6825            *
6826            * @param id the primary key of the current journal article
6827            * @param groupId the group ID
6828            * @param userId the user ID
6829            * @param classNameId the class name ID
6830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6831            * @return the previous, current, and next journal article
6832            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6833            * @throws SystemException if a system exception occurred
6834            */
6835            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
6836                    long id, long groupId, long userId, long classNameId,
6837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6838                    throws com.liferay.portal.kernel.exception.SystemException,
6839                            com.liferay.portlet.journal.NoSuchArticleException {
6840                    return getPersistence()
6841                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
6842                            orderByComparator);
6843            }
6844    
6845            /**
6846            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6847            *
6848            * @param groupId the group ID
6849            * @param userId the user ID
6850            * @param classNameId the class name ID
6851            * @return the matching journal articles that the user has permission to view
6852            * @throws SystemException if a system exception occurred
6853            */
6854            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6855                    long groupId, long userId, long classNameId)
6856                    throws com.liferay.portal.kernel.exception.SystemException {
6857                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
6858            }
6859    
6860            /**
6861            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6862            *
6863            * <p>
6864            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6865            * </p>
6866            *
6867            * @param groupId the group ID
6868            * @param userId the user ID
6869            * @param classNameId the class name ID
6870            * @param start the lower bound of the range of journal articles
6871            * @param end the upper bound of the range of journal articles (not inclusive)
6872            * @return the range of matching journal articles that the user has permission to view
6873            * @throws SystemException if a system exception occurred
6874            */
6875            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6876                    long groupId, long userId, long classNameId, int start, int end)
6877                    throws com.liferay.portal.kernel.exception.SystemException {
6878                    return getPersistence()
6879                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
6880            }
6881    
6882            /**
6883            * 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;.
6884            *
6885            * <p>
6886            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
6887            * </p>
6888            *
6889            * @param groupId the group ID
6890            * @param userId the user ID
6891            * @param classNameId the class name ID
6892            * @param start the lower bound of the range of journal articles
6893            * @param end the upper bound of the range of journal articles (not inclusive)
6894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6895            * @return the ordered range of matching journal articles that the user has permission to view
6896            * @throws SystemException if a system exception occurred
6897            */
6898            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6899                    long groupId, long userId, long classNameId, int start, int end,
6900                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6901                    throws com.liferay.portal.kernel.exception.SystemException {
6902                    return getPersistence()
6903                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
6904                            orderByComparator);
6905            }
6906    
6907            /**
6908            * 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;.
6909            *
6910            * @param id the primary key of the current journal article
6911            * @param groupId the group ID
6912            * @param userId the user ID
6913            * @param classNameId the class name ID
6914            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6915            * @return the previous, current, and next journal article
6916            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6917            * @throws SystemException if a system exception occurred
6918            */
6919            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
6920                    long id, long groupId, long userId, long classNameId,
6921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6922                    throws com.liferay.portal.kernel.exception.SystemException,
6923                            com.liferay.portlet.journal.NoSuchArticleException {
6924                    return getPersistence()
6925                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
6926                            classNameId, orderByComparator);
6927            }
6928    
6929            /**
6930            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
6931            *
6932            * @param groupId the group ID
6933            * @param userId the user ID
6934            * @param classNameId the class name ID
6935            * @throws SystemException if a system exception occurred
6936            */
6937            public static void removeByG_U_C(long groupId, long userId, long classNameId)
6938                    throws com.liferay.portal.kernel.exception.SystemException {
6939                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
6940            }
6941    
6942            /**
6943            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6944            *
6945            * @param groupId the group ID
6946            * @param userId the user ID
6947            * @param classNameId the class name ID
6948            * @return the number of matching journal articles
6949            * @throws SystemException if a system exception occurred
6950            */
6951            public static int countByG_U_C(long groupId, long userId, long classNameId)
6952                    throws com.liferay.portal.kernel.exception.SystemException {
6953                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
6954            }
6955    
6956            /**
6957            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6958            *
6959            * @param groupId the group ID
6960            * @param userId the user ID
6961            * @param classNameId the class name ID
6962            * @return the number of matching journal articles that the user has permission to view
6963            * @throws SystemException if a system exception occurred
6964            */
6965            public static int filterCountByG_U_C(long groupId, long userId,
6966                    long classNameId)
6967                    throws com.liferay.portal.kernel.exception.SystemException {
6968                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
6969            }
6970    
6971            /**
6972            * 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.
6973            *
6974            * @param groupId the group ID
6975            * @param articleId the article ID
6976            * @param version the version
6977            * @return the matching journal article
6978            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6979            * @throws SystemException if a system exception occurred
6980            */
6981            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
6982                    long groupId, java.lang.String articleId, double version)
6983                    throws com.liferay.portal.kernel.exception.SystemException,
6984                            com.liferay.portlet.journal.NoSuchArticleException {
6985                    return getPersistence().findByG_A_V(groupId, articleId, version);
6986            }
6987    
6988            /**
6989            * 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.
6990            *
6991            * @param groupId the group ID
6992            * @param articleId the article ID
6993            * @param version the version
6994            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6995            * @throws SystemException if a system exception occurred
6996            */
6997            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6998                    long groupId, java.lang.String articleId, double version)
6999                    throws com.liferay.portal.kernel.exception.SystemException {
7000                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
7001            }
7002    
7003            /**
7004            * 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.
7005            *
7006            * @param groupId the group ID
7007            * @param articleId the article ID
7008            * @param version the version
7009            * @param retrieveFromCache whether to use the finder cache
7010            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7011            * @throws SystemException if a system exception occurred
7012            */
7013            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7014                    long groupId, java.lang.String articleId, double version,
7015                    boolean retrieveFromCache)
7016                    throws com.liferay.portal.kernel.exception.SystemException {
7017                    return getPersistence()
7018                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
7019            }
7020    
7021            /**
7022            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
7023            *
7024            * @param groupId the group ID
7025            * @param articleId the article ID
7026            * @param version the version
7027            * @return the journal article that was removed
7028            * @throws SystemException if a system exception occurred
7029            */
7030            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
7031                    long groupId, java.lang.String articleId, double version)
7032                    throws com.liferay.portal.kernel.exception.SystemException,
7033                            com.liferay.portlet.journal.NoSuchArticleException {
7034                    return getPersistence().removeByG_A_V(groupId, articleId, version);
7035            }
7036    
7037            /**
7038            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
7039            *
7040            * @param groupId the group ID
7041            * @param articleId the article ID
7042            * @param version the version
7043            * @return the number of matching journal articles
7044            * @throws SystemException if a system exception occurred
7045            */
7046            public static int countByG_A_V(long groupId, java.lang.String articleId,
7047                    double version)
7048                    throws com.liferay.portal.kernel.exception.SystemException {
7049                    return getPersistence().countByG_A_V(groupId, articleId, version);
7050            }
7051    
7052            /**
7053            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7054            *
7055            * @param groupId the group ID
7056            * @param articleId the article ID
7057            * @param status the status
7058            * @return the matching journal articles
7059            * @throws SystemException if a system exception occurred
7060            */
7061            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7062                    long groupId, java.lang.String articleId, int status)
7063                    throws com.liferay.portal.kernel.exception.SystemException {
7064                    return getPersistence().findByG_A_ST(groupId, articleId, status);
7065            }
7066    
7067            /**
7068            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7069            *
7070            * <p>
7071            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7072            * </p>
7073            *
7074            * @param groupId the group ID
7075            * @param articleId the article ID
7076            * @param status the status
7077            * @param start the lower bound of the range of journal articles
7078            * @param end the upper bound of the range of journal articles (not inclusive)
7079            * @return the range of matching journal articles
7080            * @throws SystemException if a system exception occurred
7081            */
7082            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7083                    long groupId, java.lang.String articleId, int status, int start, int end)
7084                    throws com.liferay.portal.kernel.exception.SystemException {
7085                    return getPersistence()
7086                                       .findByG_A_ST(groupId, articleId, status, start, end);
7087            }
7088    
7089            /**
7090            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7091            *
7092            * <p>
7093            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7094            * </p>
7095            *
7096            * @param groupId the group ID
7097            * @param articleId the article ID
7098            * @param status the status
7099            * @param start the lower bound of the range of journal articles
7100            * @param end the upper bound of the range of journal articles (not inclusive)
7101            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7102            * @return the ordered range of matching journal articles
7103            * @throws SystemException if a system exception occurred
7104            */
7105            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7106                    long groupId, java.lang.String articleId, int status, int start,
7107                    int end,
7108                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7109                    throws com.liferay.portal.kernel.exception.SystemException {
7110                    return getPersistence()
7111                                       .findByG_A_ST(groupId, articleId, status, start, end,
7112                            orderByComparator);
7113            }
7114    
7115            /**
7116            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7117            *
7118            * @param groupId the group ID
7119            * @param articleId the article ID
7120            * @param status the status
7121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7122            * @return the first matching journal article
7123            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7124            * @throws SystemException if a system exception occurred
7125            */
7126            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
7127                    long groupId, java.lang.String articleId, int status,
7128                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7129                    throws com.liferay.portal.kernel.exception.SystemException,
7130                            com.liferay.portlet.journal.NoSuchArticleException {
7131                    return getPersistence()
7132                                       .findByG_A_ST_First(groupId, articleId, status,
7133                            orderByComparator);
7134            }
7135    
7136            /**
7137            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7138            *
7139            * @param groupId the group ID
7140            * @param articleId the article ID
7141            * @param status the status
7142            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7143            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7144            * @throws SystemException if a system exception occurred
7145            */
7146            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
7147                    long groupId, java.lang.String articleId, int status,
7148                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7149                    throws com.liferay.portal.kernel.exception.SystemException {
7150                    return getPersistence()
7151                                       .fetchByG_A_ST_First(groupId, articleId, status,
7152                            orderByComparator);
7153            }
7154    
7155            /**
7156            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7157            *
7158            * @param groupId the group ID
7159            * @param articleId the article ID
7160            * @param status the status
7161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7162            * @return the last matching journal article
7163            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7164            * @throws SystemException if a system exception occurred
7165            */
7166            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
7167                    long groupId, java.lang.String articleId, int status,
7168                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7169                    throws com.liferay.portal.kernel.exception.SystemException,
7170                            com.liferay.portlet.journal.NoSuchArticleException {
7171                    return getPersistence()
7172                                       .findByG_A_ST_Last(groupId, articleId, status,
7173                            orderByComparator);
7174            }
7175    
7176            /**
7177            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7178            *
7179            * @param groupId the group ID
7180            * @param articleId the article ID
7181            * @param status the status
7182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7183            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7184            * @throws SystemException if a system exception occurred
7185            */
7186            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
7187                    long groupId, java.lang.String articleId, int status,
7188                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7189                    throws com.liferay.portal.kernel.exception.SystemException {
7190                    return getPersistence()
7191                                       .fetchByG_A_ST_Last(groupId, articleId, status,
7192                            orderByComparator);
7193            }
7194    
7195            /**
7196            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7197            *
7198            * @param id the primary key of the current journal article
7199            * @param groupId the group ID
7200            * @param articleId the article ID
7201            * @param status the status
7202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7203            * @return the previous, current, and next journal article
7204            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7205            * @throws SystemException if a system exception occurred
7206            */
7207            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
7208                    long id, long groupId, java.lang.String articleId, int status,
7209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7210                    throws com.liferay.portal.kernel.exception.SystemException,
7211                            com.liferay.portlet.journal.NoSuchArticleException {
7212                    return getPersistence()
7213                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
7214                            orderByComparator);
7215            }
7216    
7217            /**
7218            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7219            *
7220            * @param groupId the group ID
7221            * @param articleId the article ID
7222            * @param status the status
7223            * @return the matching journal articles that the user has permission to view
7224            * @throws SystemException if a system exception occurred
7225            */
7226            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7227                    long groupId, java.lang.String articleId, int status)
7228                    throws com.liferay.portal.kernel.exception.SystemException {
7229                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
7230            }
7231    
7232            /**
7233            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7234            *
7235            * <p>
7236            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7237            * </p>
7238            *
7239            * @param groupId the group ID
7240            * @param articleId the article ID
7241            * @param status the status
7242            * @param start the lower bound of the range of journal articles
7243            * @param end the upper bound of the range of journal articles (not inclusive)
7244            * @return the range of matching journal articles that the user has permission to view
7245            * @throws SystemException if a system exception occurred
7246            */
7247            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7248                    long groupId, java.lang.String articleId, int status, int start, int end)
7249                    throws com.liferay.portal.kernel.exception.SystemException {
7250                    return getPersistence()
7251                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
7252            }
7253    
7254            /**
7255            * 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;.
7256            *
7257            * <p>
7258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7259            * </p>
7260            *
7261            * @param groupId the group ID
7262            * @param articleId the article ID
7263            * @param status the status
7264            * @param start the lower bound of the range of journal articles
7265            * @param end the upper bound of the range of journal articles (not inclusive)
7266            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7267            * @return the ordered range of matching journal articles that the user has permission to view
7268            * @throws SystemException if a system exception occurred
7269            */
7270            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7271                    long groupId, java.lang.String articleId, int status, int start,
7272                    int end,
7273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7274                    throws com.liferay.portal.kernel.exception.SystemException {
7275                    return getPersistence()
7276                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
7277                            orderByComparator);
7278            }
7279    
7280            /**
7281            * 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;.
7282            *
7283            * @param id the primary key of the current journal article
7284            * @param groupId the group ID
7285            * @param articleId the article ID
7286            * @param status the status
7287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7288            * @return the previous, current, and next journal article
7289            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7290            * @throws SystemException if a system exception occurred
7291            */
7292            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
7293                    long id, long groupId, java.lang.String articleId, int status,
7294                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7295                    throws com.liferay.portal.kernel.exception.SystemException,
7296                            com.liferay.portlet.journal.NoSuchArticleException {
7297                    return getPersistence()
7298                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
7299                            status, orderByComparator);
7300            }
7301    
7302            /**
7303            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7304            *
7305            * @param groupId the group ID
7306            * @param articleId the article ID
7307            * @param statuses the statuses
7308            * @return the matching journal articles that the user has permission to view
7309            * @throws SystemException if a system exception occurred
7310            */
7311            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7312                    long groupId, java.lang.String articleId, int[] statuses)
7313                    throws com.liferay.portal.kernel.exception.SystemException {
7314                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
7315            }
7316    
7317            /**
7318            * 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;.
7319            *
7320            * <p>
7321            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7322            * </p>
7323            *
7324            * @param groupId the group ID
7325            * @param articleId the article ID
7326            * @param statuses the statuses
7327            * @param start the lower bound of the range of journal articles
7328            * @param end the upper bound of the range of journal articles (not inclusive)
7329            * @return the range of matching journal articles that the user has permission to view
7330            * @throws SystemException if a system exception occurred
7331            */
7332            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7333                    long groupId, java.lang.String articleId, int[] statuses, int start,
7334                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7335                    return getPersistence()
7336                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
7337            }
7338    
7339            /**
7340            * 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;.
7341            *
7342            * <p>
7343            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7344            * </p>
7345            *
7346            * @param groupId the group ID
7347            * @param articleId the article ID
7348            * @param statuses the statuses
7349            * @param start the lower bound of the range of journal articles
7350            * @param end the upper bound of the range of journal articles (not inclusive)
7351            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7352            * @return the ordered range of matching journal articles that the user has permission to view
7353            * @throws SystemException if a system exception occurred
7354            */
7355            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7356                    long groupId, java.lang.String articleId, int[] statuses, int start,
7357                    int end,
7358                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7359                    throws com.liferay.portal.kernel.exception.SystemException {
7360                    return getPersistence()
7361                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
7362                            end, orderByComparator);
7363            }
7364    
7365            /**
7366            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7367            *
7368            * <p>
7369            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7370            * </p>
7371            *
7372            * @param groupId the group ID
7373            * @param articleId the article ID
7374            * @param statuses the statuses
7375            * @return the matching journal articles
7376            * @throws SystemException if a system exception occurred
7377            */
7378            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7379                    long groupId, java.lang.String articleId, int[] statuses)
7380                    throws com.liferay.portal.kernel.exception.SystemException {
7381                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
7382            }
7383    
7384            /**
7385            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7386            *
7387            * <p>
7388            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7389            * </p>
7390            *
7391            * @param groupId the group ID
7392            * @param articleId the article ID
7393            * @param statuses the statuses
7394            * @param start the lower bound of the range of journal articles
7395            * @param end the upper bound of the range of journal articles (not inclusive)
7396            * @return the range of matching journal articles
7397            * @throws SystemException if a system exception occurred
7398            */
7399            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7400                    long groupId, java.lang.String articleId, int[] statuses, int start,
7401                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7402                    return getPersistence()
7403                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
7404            }
7405    
7406            /**
7407            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7408            *
7409            * <p>
7410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7411            * </p>
7412            *
7413            * @param groupId the group ID
7414            * @param articleId the article ID
7415            * @param statuses the statuses
7416            * @param start the lower bound of the range of journal articles
7417            * @param end the upper bound of the range of journal articles (not inclusive)
7418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7419            * @return the ordered range of matching journal articles
7420            * @throws SystemException if a system exception occurred
7421            */
7422            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7423                    long groupId, java.lang.String articleId, int[] statuses, int start,
7424                    int end,
7425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7426                    throws com.liferay.portal.kernel.exception.SystemException {
7427                    return getPersistence()
7428                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
7429                            orderByComparator);
7430            }
7431    
7432            /**
7433            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
7434            *
7435            * @param groupId the group ID
7436            * @param articleId the article ID
7437            * @param status the status
7438            * @throws SystemException if a system exception occurred
7439            */
7440            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
7441                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7442                    getPersistence().removeByG_A_ST(groupId, articleId, status);
7443            }
7444    
7445            /**
7446            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7447            *
7448            * @param groupId the group ID
7449            * @param articleId the article ID
7450            * @param status the status
7451            * @return the number of matching journal articles
7452            * @throws SystemException if a system exception occurred
7453            */
7454            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7455                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7456                    return getPersistence().countByG_A_ST(groupId, articleId, status);
7457            }
7458    
7459            /**
7460            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7461            *
7462            * @param groupId the group ID
7463            * @param articleId the article ID
7464            * @param statuses the statuses
7465            * @return the number of matching journal articles
7466            * @throws SystemException if a system exception occurred
7467            */
7468            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7469                    int[] statuses)
7470                    throws com.liferay.portal.kernel.exception.SystemException {
7471                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
7472            }
7473    
7474            /**
7475            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7476            *
7477            * @param groupId the group ID
7478            * @param articleId the article ID
7479            * @param status the status
7480            * @return the number of matching journal articles that the user has permission to view
7481            * @throws SystemException if a system exception occurred
7482            */
7483            public static int filterCountByG_A_ST(long groupId,
7484                    java.lang.String articleId, int status)
7485                    throws com.liferay.portal.kernel.exception.SystemException {
7486                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
7487            }
7488    
7489            /**
7490            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7491            *
7492            * @param groupId the group ID
7493            * @param articleId the article ID
7494            * @param statuses the statuses
7495            * @return the number of matching journal articles that the user has permission to view
7496            * @throws SystemException if a system exception occurred
7497            */
7498            public static int filterCountByG_A_ST(long groupId,
7499                    java.lang.String articleId, int[] statuses)
7500                    throws com.liferay.portal.kernel.exception.SystemException {
7501                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
7502            }
7503    
7504            /**
7505            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7506            *
7507            * @param groupId the group ID
7508            * @param urlTitle the url title
7509            * @param status the status
7510            * @return the matching journal articles
7511            * @throws SystemException if a system exception occurred
7512            */
7513            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7514                    long groupId, java.lang.String urlTitle, int status)
7515                    throws com.liferay.portal.kernel.exception.SystemException {
7516                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
7517            }
7518    
7519            /**
7520            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7521            *
7522            * <p>
7523            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7524            * </p>
7525            *
7526            * @param groupId the group ID
7527            * @param urlTitle the url title
7528            * @param status the status
7529            * @param start the lower bound of the range of journal articles
7530            * @param end the upper bound of the range of journal articles (not inclusive)
7531            * @return the range of matching journal articles
7532            * @throws SystemException if a system exception occurred
7533            */
7534            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7535                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7536                    throws com.liferay.portal.kernel.exception.SystemException {
7537                    return getPersistence()
7538                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
7539            }
7540    
7541            /**
7542            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7543            *
7544            * <p>
7545            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7546            * </p>
7547            *
7548            * @param groupId the group ID
7549            * @param urlTitle the url title
7550            * @param status the status
7551            * @param start the lower bound of the range of journal articles
7552            * @param end the upper bound of the range of journal articles (not inclusive)
7553            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7554            * @return the ordered range of matching journal articles
7555            * @throws SystemException if a system exception occurred
7556            */
7557            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7558                    long groupId, java.lang.String urlTitle, int status, int start,
7559                    int end,
7560                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7561                    throws com.liferay.portal.kernel.exception.SystemException {
7562                    return getPersistence()
7563                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
7564                            orderByComparator);
7565            }
7566    
7567            /**
7568            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7569            *
7570            * @param groupId the group ID
7571            * @param urlTitle the url title
7572            * @param status the status
7573            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7574            * @return the first matching journal article
7575            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7576            * @throws SystemException if a system exception occurred
7577            */
7578            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
7579                    long groupId, java.lang.String urlTitle, int status,
7580                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7581                    throws com.liferay.portal.kernel.exception.SystemException,
7582                            com.liferay.portlet.journal.NoSuchArticleException {
7583                    return getPersistence()
7584                                       .findByG_UT_ST_First(groupId, urlTitle, status,
7585                            orderByComparator);
7586            }
7587    
7588            /**
7589            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7590            *
7591            * @param groupId the group ID
7592            * @param urlTitle the url title
7593            * @param status the status
7594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7595            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7596            * @throws SystemException if a system exception occurred
7597            */
7598            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
7599                    long groupId, java.lang.String urlTitle, int status,
7600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7601                    throws com.liferay.portal.kernel.exception.SystemException {
7602                    return getPersistence()
7603                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
7604                            orderByComparator);
7605            }
7606    
7607            /**
7608            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7609            *
7610            * @param groupId the group ID
7611            * @param urlTitle the url title
7612            * @param status the status
7613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7614            * @return the last matching journal article
7615            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7616            * @throws SystemException if a system exception occurred
7617            */
7618            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
7619                    long groupId, java.lang.String urlTitle, int status,
7620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7621                    throws com.liferay.portal.kernel.exception.SystemException,
7622                            com.liferay.portlet.journal.NoSuchArticleException {
7623                    return getPersistence()
7624                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
7625                            orderByComparator);
7626            }
7627    
7628            /**
7629            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7630            *
7631            * @param groupId the group ID
7632            * @param urlTitle the url title
7633            * @param status the status
7634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7635            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7636            * @throws SystemException if a system exception occurred
7637            */
7638            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
7639                    long groupId, java.lang.String urlTitle, int status,
7640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7641                    throws com.liferay.portal.kernel.exception.SystemException {
7642                    return getPersistence()
7643                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
7644                            orderByComparator);
7645            }
7646    
7647            /**
7648            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7649            *
7650            * @param id the primary key of the current journal article
7651            * @param groupId the group ID
7652            * @param urlTitle the url title
7653            * @param status the status
7654            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7655            * @return the previous, current, and next journal article
7656            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7657            * @throws SystemException if a system exception occurred
7658            */
7659            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
7660                    long id, long groupId, java.lang.String urlTitle, int status,
7661                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7662                    throws com.liferay.portal.kernel.exception.SystemException,
7663                            com.liferay.portlet.journal.NoSuchArticleException {
7664                    return getPersistence()
7665                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
7666                            orderByComparator);
7667            }
7668    
7669            /**
7670            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7671            *
7672            * @param groupId the group ID
7673            * @param urlTitle the url title
7674            * @param status the status
7675            * @return the matching journal articles that the user has permission to view
7676            * @throws SystemException if a system exception occurred
7677            */
7678            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7679                    long groupId, java.lang.String urlTitle, int status)
7680                    throws com.liferay.portal.kernel.exception.SystemException {
7681                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
7682            }
7683    
7684            /**
7685            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7686            *
7687            * <p>
7688            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7689            * </p>
7690            *
7691            * @param groupId the group ID
7692            * @param urlTitle the url title
7693            * @param status the status
7694            * @param start the lower bound of the range of journal articles
7695            * @param end the upper bound of the range of journal articles (not inclusive)
7696            * @return the range of matching journal articles that the user has permission to view
7697            * @throws SystemException if a system exception occurred
7698            */
7699            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7700                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7701                    throws com.liferay.portal.kernel.exception.SystemException {
7702                    return getPersistence()
7703                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7704            }
7705    
7706            /**
7707            * 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;.
7708            *
7709            * <p>
7710            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7711            * </p>
7712            *
7713            * @param groupId the group ID
7714            * @param urlTitle the url title
7715            * @param status the status
7716            * @param start the lower bound of the range of journal articles
7717            * @param end the upper bound of the range of journal articles (not inclusive)
7718            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7719            * @return the ordered range of matching journal articles that the user has permission to view
7720            * @throws SystemException if a system exception occurred
7721            */
7722            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7723                    long groupId, java.lang.String urlTitle, int status, int start,
7724                    int end,
7725                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7726                    throws com.liferay.portal.kernel.exception.SystemException {
7727                    return getPersistence()
7728                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7729                            orderByComparator);
7730            }
7731    
7732            /**
7733            * 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;.
7734            *
7735            * @param id the primary key of the current journal article
7736            * @param groupId the group ID
7737            * @param urlTitle the url title
7738            * @param status the status
7739            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7740            * @return the previous, current, and next journal article
7741            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7742            * @throws SystemException if a system exception occurred
7743            */
7744            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
7745                    long id, long groupId, java.lang.String urlTitle, int status,
7746                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7747                    throws com.liferay.portal.kernel.exception.SystemException,
7748                            com.liferay.portlet.journal.NoSuchArticleException {
7749                    return getPersistence()
7750                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7751                            status, orderByComparator);
7752            }
7753    
7754            /**
7755            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7756            *
7757            * @param groupId the group ID
7758            * @param urlTitle the url title
7759            * @param status the status
7760            * @throws SystemException if a system exception occurred
7761            */
7762            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7763                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7764                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7765            }
7766    
7767            /**
7768            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7769            *
7770            * @param groupId the group ID
7771            * @param urlTitle the url title
7772            * @param status the status
7773            * @return the number of matching journal articles
7774            * @throws SystemException if a system exception occurred
7775            */
7776            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7777                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7778                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7779            }
7780    
7781            /**
7782            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7783            *
7784            * @param groupId the group ID
7785            * @param urlTitle the url title
7786            * @param status the status
7787            * @return the number of matching journal articles that the user has permission to view
7788            * @throws SystemException if a system exception occurred
7789            */
7790            public static int filterCountByG_UT_ST(long groupId,
7791                    java.lang.String urlTitle, int status)
7792                    throws com.liferay.portal.kernel.exception.SystemException {
7793                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7794            }
7795    
7796            /**
7797            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7798            *
7799            * @param companyId the company ID
7800            * @param version the version
7801            * @param status the status
7802            * @return the matching journal articles
7803            * @throws SystemException if a system exception occurred
7804            */
7805            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7806                    long companyId, double version, int status)
7807                    throws com.liferay.portal.kernel.exception.SystemException {
7808                    return getPersistence().findByC_V_ST(companyId, version, status);
7809            }
7810    
7811            /**
7812            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7813            *
7814            * <p>
7815            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7816            * </p>
7817            *
7818            * @param companyId the company ID
7819            * @param version the version
7820            * @param status the status
7821            * @param start the lower bound of the range of journal articles
7822            * @param end the upper bound of the range of journal articles (not inclusive)
7823            * @return the range of matching journal articles
7824            * @throws SystemException if a system exception occurred
7825            */
7826            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7827                    long companyId, double version, int status, int start, int end)
7828                    throws com.liferay.portal.kernel.exception.SystemException {
7829                    return getPersistence()
7830                                       .findByC_V_ST(companyId, version, status, start, end);
7831            }
7832    
7833            /**
7834            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7835            *
7836            * <p>
7837            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
7838            * </p>
7839            *
7840            * @param companyId the company ID
7841            * @param version the version
7842            * @param status the status
7843            * @param start the lower bound of the range of journal articles
7844            * @param end the upper bound of the range of journal articles (not inclusive)
7845            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7846            * @return the ordered range of matching journal articles
7847            * @throws SystemException if a system exception occurred
7848            */
7849            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7850                    long companyId, double version, int status, int start, int end,
7851                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7852                    throws com.liferay.portal.kernel.exception.SystemException {
7853                    return getPersistence()
7854                                       .findByC_V_ST(companyId, version, status, start, end,
7855                            orderByComparator);
7856            }
7857    
7858            /**
7859            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7860            *
7861            * @param companyId the company ID
7862            * @param version the version
7863            * @param status the status
7864            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7865            * @return the first matching journal article
7866            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7867            * @throws SystemException if a system exception occurred
7868            */
7869            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
7870                    long companyId, double version, int status,
7871                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7872                    throws com.liferay.portal.kernel.exception.SystemException,
7873                            com.liferay.portlet.journal.NoSuchArticleException {
7874                    return getPersistence()
7875                                       .findByC_V_ST_First(companyId, version, status,
7876                            orderByComparator);
7877            }
7878    
7879            /**
7880            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7881            *
7882            * @param companyId the company ID
7883            * @param version the version
7884            * @param status the status
7885            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7886            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7887            * @throws SystemException if a system exception occurred
7888            */
7889            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
7890                    long companyId, double version, int status,
7891                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7892                    throws com.liferay.portal.kernel.exception.SystemException {
7893                    return getPersistence()
7894                                       .fetchByC_V_ST_First(companyId, version, status,
7895                            orderByComparator);
7896            }
7897    
7898            /**
7899            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7900            *
7901            * @param companyId the company ID
7902            * @param version the version
7903            * @param status the status
7904            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7905            * @return the last matching journal article
7906            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7907            * @throws SystemException if a system exception occurred
7908            */
7909            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
7910                    long companyId, double version, int status,
7911                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7912                    throws com.liferay.portal.kernel.exception.SystemException,
7913                            com.liferay.portlet.journal.NoSuchArticleException {
7914                    return getPersistence()
7915                                       .findByC_V_ST_Last(companyId, version, status,
7916                            orderByComparator);
7917            }
7918    
7919            /**
7920            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7921            *
7922            * @param companyId the company ID
7923            * @param version the version
7924            * @param status the status
7925            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7926            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7927            * @throws SystemException if a system exception occurred
7928            */
7929            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
7930                    long companyId, double version, int status,
7931                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7932                    throws com.liferay.portal.kernel.exception.SystemException {
7933                    return getPersistence()
7934                                       .fetchByC_V_ST_Last(companyId, version, status,
7935                            orderByComparator);
7936            }
7937    
7938            /**
7939            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7940            *
7941            * @param id the primary key of the current journal article
7942            * @param companyId the company ID
7943            * @param version the version
7944            * @param status the status
7945            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7946            * @return the previous, current, and next journal article
7947            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7948            * @throws SystemException if a system exception occurred
7949            */
7950            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
7951                    long id, long companyId, double version, int status,
7952                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7953                    throws com.liferay.portal.kernel.exception.SystemException,
7954                            com.liferay.portlet.journal.NoSuchArticleException {
7955                    return getPersistence()
7956                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7957                            orderByComparator);
7958            }
7959    
7960            /**
7961            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7962            *
7963            * @param companyId the company ID
7964            * @param version the version
7965            * @param status the status
7966            * @throws SystemException if a system exception occurred
7967            */
7968            public static void removeByC_V_ST(long companyId, double version, int status)
7969                    throws com.liferay.portal.kernel.exception.SystemException {
7970                    getPersistence().removeByC_V_ST(companyId, version, status);
7971            }
7972    
7973            /**
7974            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7975            *
7976            * @param companyId the company ID
7977            * @param version the version
7978            * @param status the status
7979            * @return the number of matching journal articles
7980            * @throws SystemException if a system exception occurred
7981            */
7982            public static int countByC_V_ST(long companyId, double version, int status)
7983                    throws com.liferay.portal.kernel.exception.SystemException {
7984                    return getPersistence().countByC_V_ST(companyId, version, status);
7985            }
7986    
7987            /**
7988            * Caches the journal article in the entity cache if it is enabled.
7989            *
7990            * @param journalArticle the journal article
7991            */
7992            public static void cacheResult(
7993                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7994                    getPersistence().cacheResult(journalArticle);
7995            }
7996    
7997            /**
7998            * Caches the journal articles in the entity cache if it is enabled.
7999            *
8000            * @param journalArticles the journal articles
8001            */
8002            public static void cacheResult(
8003                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
8004                    getPersistence().cacheResult(journalArticles);
8005            }
8006    
8007            /**
8008            * Creates a new journal article with the primary key. Does not add the journal article to the database.
8009            *
8010            * @param id the primary key for the new journal article
8011            * @return the new journal article
8012            */
8013            public static com.liferay.portlet.journal.model.JournalArticle create(
8014                    long id) {
8015                    return getPersistence().create(id);
8016            }
8017    
8018            /**
8019            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
8020            *
8021            * @param id the primary key of the journal article
8022            * @return the journal article that was removed
8023            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8024            * @throws SystemException if a system exception occurred
8025            */
8026            public static com.liferay.portlet.journal.model.JournalArticle remove(
8027                    long id)
8028                    throws com.liferay.portal.kernel.exception.SystemException,
8029                            com.liferay.portlet.journal.NoSuchArticleException {
8030                    return getPersistence().remove(id);
8031            }
8032    
8033            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
8034                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
8035                    throws com.liferay.portal.kernel.exception.SystemException {
8036                    return getPersistence().updateImpl(journalArticle);
8037            }
8038    
8039            /**
8040            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
8041            *
8042            * @param id the primary key of the journal article
8043            * @return the journal article
8044            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8045            * @throws SystemException if a system exception occurred
8046            */
8047            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
8048                    long id)
8049                    throws com.liferay.portal.kernel.exception.SystemException,
8050                            com.liferay.portlet.journal.NoSuchArticleException {
8051                    return getPersistence().findByPrimaryKey(id);
8052            }
8053    
8054            /**
8055            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
8056            *
8057            * @param id the primary key of the journal article
8058            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
8059            * @throws SystemException if a system exception occurred
8060            */
8061            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
8062                    long id) throws com.liferay.portal.kernel.exception.SystemException {
8063                    return getPersistence().fetchByPrimaryKey(id);
8064            }
8065    
8066            /**
8067            * Returns all the journal articles.
8068            *
8069            * @return the journal articles
8070            * @throws SystemException if a system exception occurred
8071            */
8072            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
8073                    throws com.liferay.portal.kernel.exception.SystemException {
8074                    return getPersistence().findAll();
8075            }
8076    
8077            /**
8078            * Returns a range of all the journal articles.
8079            *
8080            * <p>
8081            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
8082            * </p>
8083            *
8084            * @param start the lower bound of the range of journal articles
8085            * @param end the upper bound of the range of journal articles (not inclusive)
8086            * @return the range of journal articles
8087            * @throws SystemException if a system exception occurred
8088            */
8089            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
8090                    int start, int end)
8091                    throws com.liferay.portal.kernel.exception.SystemException {
8092                    return getPersistence().findAll(start, end);
8093            }
8094    
8095            /**
8096            * Returns an ordered range of all the journal articles.
8097            *
8098            * <p>
8099            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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.
8100            * </p>
8101            *
8102            * @param start the lower bound of the range of journal articles
8103            * @param end the upper bound of the range of journal articles (not inclusive)
8104            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8105            * @return the ordered range of journal articles
8106            * @throws SystemException if a system exception occurred
8107            */
8108            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
8109                    int start, int end,
8110                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8111                    throws com.liferay.portal.kernel.exception.SystemException {
8112                    return getPersistence().findAll(start, end, orderByComparator);
8113            }
8114    
8115            /**
8116            * Removes all the journal articles from the database.
8117            *
8118            * @throws SystemException if a system exception occurred
8119            */
8120            public static void removeAll()
8121                    throws com.liferay.portal.kernel.exception.SystemException {
8122                    getPersistence().removeAll();
8123            }
8124    
8125            /**
8126            * Returns the number of journal articles.
8127            *
8128            * @return the number of journal articles
8129            * @throws SystemException if a system exception occurred
8130            */
8131            public static int countAll()
8132                    throws com.liferay.portal.kernel.exception.SystemException {
8133                    return getPersistence().countAll();
8134            }
8135    
8136            public static JournalArticlePersistence getPersistence() {
8137                    if (_persistence == null) {
8138                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
8139    
8140                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
8141                                    "_persistence");
8142                    }
8143    
8144                    return _persistence;
8145            }
8146    
8147            /**
8148             * @deprecated As of 6.2.0
8149             */
8150            public void setPersistence(JournalArticlePersistence persistence) {
8151            }
8152    
8153            private static JournalArticlePersistence _persistence;
8154    }