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 userId = &#63; and classNameId = &#63;.
5270            *
5271            * @param groupId the group ID
5272            * @param userId the user ID
5273            * @param classNameId the class name ID
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_U_C(
5278                    long groupId, long userId, long classNameId)
5279                    throws com.liferay.portal.kernel.exception.SystemException {
5280                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
5281            }
5282    
5283            /**
5284            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#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 userId the user ID
5292            * @param classNameId the class name ID
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_U_C(
5299                    long groupId, long userId, long classNameId, int start, int end)
5300                    throws com.liferay.portal.kernel.exception.SystemException {
5301                    return getPersistence()
5302                                       .findByG_U_C(groupId, userId, classNameId, start, end);
5303            }
5304    
5305            /**
5306            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#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 userId the user ID
5314            * @param classNameId the class name ID
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_U_C(
5322                    long groupId, long userId, long classNameId, 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_U_C(groupId, userId, classNameId, start, end,
5327                            orderByComparator);
5328            }
5329    
5330            /**
5331            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5332            *
5333            * @param groupId the group ID
5334            * @param userId the user ID
5335            * @param classNameId the class name ID
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_U_C_First(
5342                    long groupId, long userId, long classNameId,
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_U_C_First(groupId, userId, classNameId,
5348                            orderByComparator);
5349            }
5350    
5351            /**
5352            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5353            *
5354            * @param groupId the group ID
5355            * @param userId the user ID
5356            * @param classNameId the class name ID
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_U_C_First(
5362                    long groupId, long userId, long classNameId,
5363                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5364                    throws com.liferay.portal.kernel.exception.SystemException {
5365                    return getPersistence()
5366                                       .fetchByG_U_C_First(groupId, userId, classNameId,
5367                            orderByComparator);
5368            }
5369    
5370            /**
5371            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5372            *
5373            * @param groupId the group ID
5374            * @param userId the user ID
5375            * @param classNameId the class name ID
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_U_C_Last(
5382                    long groupId, long userId, long classNameId,
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_U_C_Last(groupId, userId, classNameId,
5388                            orderByComparator);
5389            }
5390    
5391            /**
5392            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5393            *
5394            * @param groupId the group ID
5395            * @param userId the user ID
5396            * @param classNameId the class name ID
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_U_C_Last(
5402                    long groupId, long userId, long classNameId,
5403                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5404                    throws com.liferay.portal.kernel.exception.SystemException {
5405                    return getPersistence()
5406                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
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 userId = &#63; and classNameId = &#63;.
5412            *
5413            * @param id the primary key of the current journal article
5414            * @param groupId the group ID
5415            * @param userId the user ID
5416            * @param classNameId the class name ID
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_U_C_PrevAndNext(
5423                    long id, long groupId, long userId, long classNameId,
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_U_C_PrevAndNext(id, groupId, userId, classNameId,
5429                            orderByComparator);
5430            }
5431    
5432            /**
5433            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5434            *
5435            * @param groupId the group ID
5436            * @param userId the user ID
5437            * @param classNameId the class name ID
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_U_C(
5442                    long groupId, long userId, long classNameId)
5443                    throws com.liferay.portal.kernel.exception.SystemException {
5444                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
5445            }
5446    
5447            /**
5448            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#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 userId the user ID
5456            * @param classNameId the class name ID
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_U_C(
5463                    long groupId, long userId, long classNameId, int start, int end)
5464                    throws com.liferay.portal.kernel.exception.SystemException {
5465                    return getPersistence()
5466                                       .filterFindByG_U_C(groupId, userId, classNameId, 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 userId = &#63; and classNameId = &#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 userId the user ID
5478            * @param classNameId the class name ID
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_U_C(
5486                    long groupId, long userId, long classNameId, 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_U_C(groupId, userId, classNameId, 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 userId = &#63; and classNameId = &#63;.
5496            *
5497            * @param id the primary key of the current journal article
5498            * @param groupId the group ID
5499            * @param userId the user ID
5500            * @param classNameId the class name ID
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_U_C_PrevAndNext(
5507                    long id, long groupId, long userId, long classNameId,
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_U_C_PrevAndNext(id, groupId, userId,
5513                            classNameId, orderByComparator);
5514            }
5515    
5516            /**
5517            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
5518            *
5519            * @param groupId the group ID
5520            * @param userId the user ID
5521            * @param classNameId the class name ID
5522            * @throws SystemException if a system exception occurred
5523            */
5524            public static void removeByG_U_C(long groupId, long userId, long classNameId)
5525                    throws com.liferay.portal.kernel.exception.SystemException {
5526                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
5527            }
5528    
5529            /**
5530            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5531            *
5532            * @param groupId the group ID
5533            * @param userId the user ID
5534            * @param classNameId the class name ID
5535            * @return the number of matching journal articles
5536            * @throws SystemException if a system exception occurred
5537            */
5538            public static int countByG_U_C(long groupId, long userId, long classNameId)
5539                    throws com.liferay.portal.kernel.exception.SystemException {
5540                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
5541            }
5542    
5543            /**
5544            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5545            *
5546            * @param groupId the group ID
5547            * @param userId the user ID
5548            * @param classNameId the class name ID
5549            * @return the number of matching journal articles that the user has permission to view
5550            * @throws SystemException if a system exception occurred
5551            */
5552            public static int filterCountByG_U_C(long groupId, long userId,
5553                    long classNameId)
5554                    throws com.liferay.portal.kernel.exception.SystemException {
5555                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
5556            }
5557    
5558            /**
5559            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5560            *
5561            * @param groupId the group ID
5562            * @param folderId the folder ID
5563            * @param status the status
5564            * @return the matching journal articles
5565            * @throws SystemException if a system exception occurred
5566            */
5567            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5568                    long groupId, long folderId, int status)
5569                    throws com.liferay.portal.kernel.exception.SystemException {
5570                    return getPersistence().findByG_F_ST(groupId, folderId, status);
5571            }
5572    
5573            /**
5574            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5575            *
5576            * <p>
5577            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5578            * </p>
5579            *
5580            * @param groupId the group ID
5581            * @param folderId the folder ID
5582            * @param status the status
5583            * @param start the lower bound of the range of journal articles
5584            * @param end the upper bound of the range of journal articles (not inclusive)
5585            * @return the range of matching journal articles
5586            * @throws SystemException if a system exception occurred
5587            */
5588            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5589                    long groupId, long folderId, int status, int start, int end)
5590                    throws com.liferay.portal.kernel.exception.SystemException {
5591                    return getPersistence()
5592                                       .findByG_F_ST(groupId, folderId, status, start, end);
5593            }
5594    
5595            /**
5596            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5597            *
5598            * <p>
5599            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5600            * </p>
5601            *
5602            * @param groupId the group ID
5603            * @param folderId the folder ID
5604            * @param status the status
5605            * @param start the lower bound of the range of journal articles
5606            * @param end the upper bound of the range of journal articles (not inclusive)
5607            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5608            * @return the ordered range of matching journal articles
5609            * @throws SystemException if a system exception occurred
5610            */
5611            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5612                    long groupId, long folderId, int status, int start, int end,
5613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5614                    throws com.liferay.portal.kernel.exception.SystemException {
5615                    return getPersistence()
5616                                       .findByG_F_ST(groupId, folderId, status, start, end,
5617                            orderByComparator);
5618            }
5619    
5620            /**
5621            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5622            *
5623            * @param groupId the group ID
5624            * @param folderId the folder ID
5625            * @param status the status
5626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5627            * @return the first matching journal article
5628            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5629            * @throws SystemException if a system exception occurred
5630            */
5631            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
5632                    long groupId, long folderId, int status,
5633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5634                    throws com.liferay.portal.kernel.exception.SystemException,
5635                            com.liferay.portlet.journal.NoSuchArticleException {
5636                    return getPersistence()
5637                                       .findByG_F_ST_First(groupId, folderId, status,
5638                            orderByComparator);
5639            }
5640    
5641            /**
5642            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5643            *
5644            * @param groupId the group ID
5645            * @param folderId the folder ID
5646            * @param status the status
5647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5648            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5649            * @throws SystemException if a system exception occurred
5650            */
5651            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
5652                    long groupId, long folderId, int status,
5653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5654                    throws com.liferay.portal.kernel.exception.SystemException {
5655                    return getPersistence()
5656                                       .fetchByG_F_ST_First(groupId, folderId, status,
5657                            orderByComparator);
5658            }
5659    
5660            /**
5661            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5662            *
5663            * @param groupId the group ID
5664            * @param folderId the folder ID
5665            * @param status the status
5666            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5667            * @return the last matching journal article
5668            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5669            * @throws SystemException if a system exception occurred
5670            */
5671            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
5672                    long groupId, long folderId, int status,
5673                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5674                    throws com.liferay.portal.kernel.exception.SystemException,
5675                            com.liferay.portlet.journal.NoSuchArticleException {
5676                    return getPersistence()
5677                                       .findByG_F_ST_Last(groupId, folderId, status,
5678                            orderByComparator);
5679            }
5680    
5681            /**
5682            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5683            *
5684            * @param groupId the group ID
5685            * @param folderId the folder ID
5686            * @param status the status
5687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5688            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5689            * @throws SystemException if a system exception occurred
5690            */
5691            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
5692                    long groupId, long folderId, int status,
5693                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5694                    throws com.liferay.portal.kernel.exception.SystemException {
5695                    return getPersistence()
5696                                       .fetchByG_F_ST_Last(groupId, folderId, status,
5697                            orderByComparator);
5698            }
5699    
5700            /**
5701            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5702            *
5703            * @param id the primary key of the current journal article
5704            * @param groupId the group ID
5705            * @param folderId the folder ID
5706            * @param status the status
5707            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5708            * @return the previous, current, and next journal article
5709            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5710            * @throws SystemException if a system exception occurred
5711            */
5712            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
5713                    long id, long groupId, long folderId, int status,
5714                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5715                    throws com.liferay.portal.kernel.exception.SystemException,
5716                            com.liferay.portlet.journal.NoSuchArticleException {
5717                    return getPersistence()
5718                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
5719                            orderByComparator);
5720            }
5721    
5722            /**
5723            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5724            *
5725            * @param groupId the group ID
5726            * @param folderId the folder ID
5727            * @param status the status
5728            * @return the matching journal articles that the user has permission to view
5729            * @throws SystemException if a system exception occurred
5730            */
5731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5732                    long groupId, long folderId, int status)
5733                    throws com.liferay.portal.kernel.exception.SystemException {
5734                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
5735            }
5736    
5737            /**
5738            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5739            *
5740            * <p>
5741            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5742            * </p>
5743            *
5744            * @param groupId the group ID
5745            * @param folderId the folder ID
5746            * @param status the status
5747            * @param start the lower bound of the range of journal articles
5748            * @param end the upper bound of the range of journal articles (not inclusive)
5749            * @return the range of matching journal articles that the user has permission to view
5750            * @throws SystemException if a system exception occurred
5751            */
5752            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5753                    long groupId, long folderId, int status, int start, int end)
5754                    throws com.liferay.portal.kernel.exception.SystemException {
5755                    return getPersistence()
5756                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
5757            }
5758    
5759            /**
5760            * 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;.
5761            *
5762            * <p>
5763            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5764            * </p>
5765            *
5766            * @param groupId the group ID
5767            * @param folderId the folder ID
5768            * @param status the status
5769            * @param start the lower bound of the range of journal articles
5770            * @param end the upper bound of the range of journal articles (not inclusive)
5771            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5772            * @return the ordered range of matching journal articles that the user has permission to view
5773            * @throws SystemException if a system exception occurred
5774            */
5775            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5776                    long groupId, long folderId, int status, int start, int end,
5777                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5778                    throws com.liferay.portal.kernel.exception.SystemException {
5779                    return getPersistence()
5780                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
5781                            orderByComparator);
5782            }
5783    
5784            /**
5785            * 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;.
5786            *
5787            * @param id the primary key of the current journal article
5788            * @param groupId the group ID
5789            * @param folderId the folder ID
5790            * @param status the status
5791            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5792            * @return the previous, current, and next journal article
5793            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5794            * @throws SystemException if a system exception occurred
5795            */
5796            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
5797                    long id, long groupId, long folderId, int status,
5798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5799                    throws com.liferay.portal.kernel.exception.SystemException,
5800                            com.liferay.portlet.journal.NoSuchArticleException {
5801                    return getPersistence()
5802                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
5803                            status, orderByComparator);
5804            }
5805    
5806            /**
5807            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5808            *
5809            * @param groupId the group ID
5810            * @param folderId the folder ID
5811            * @param statuses the statuses
5812            * @return the matching journal articles that the user has permission to view
5813            * @throws SystemException if a system exception occurred
5814            */
5815            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5816                    long groupId, long folderId, int[] statuses)
5817                    throws com.liferay.portal.kernel.exception.SystemException {
5818                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
5819            }
5820    
5821            /**
5822            * 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;.
5823            *
5824            * <p>
5825            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5826            * </p>
5827            *
5828            * @param groupId the group ID
5829            * @param folderId the folder ID
5830            * @param statuses the statuses
5831            * @param start the lower bound of the range of journal articles
5832            * @param end the upper bound of the range of journal articles (not inclusive)
5833            * @return the range of matching journal articles that the user has permission to view
5834            * @throws SystemException if a system exception occurred
5835            */
5836            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5837                    long groupId, long folderId, int[] statuses, int start, int end)
5838                    throws com.liferay.portal.kernel.exception.SystemException {
5839                    return getPersistence()
5840                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
5841            }
5842    
5843            /**
5844            * 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;.
5845            *
5846            * <p>
5847            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5848            * </p>
5849            *
5850            * @param groupId the group ID
5851            * @param folderId the folder ID
5852            * @param statuses the statuses
5853            * @param start the lower bound of the range of journal articles
5854            * @param end the upper bound of the range of journal articles (not inclusive)
5855            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5856            * @return the ordered range of matching journal articles that the user has permission to view
5857            * @throws SystemException if a system exception occurred
5858            */
5859            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5860                    long groupId, long folderId, int[] statuses, int start, int end,
5861                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5862                    throws com.liferay.portal.kernel.exception.SystemException {
5863                    return getPersistence()
5864                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
5865                            orderByComparator);
5866            }
5867    
5868            /**
5869            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5870            *
5871            * <p>
5872            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5873            * </p>
5874            *
5875            * @param groupId the group ID
5876            * @param folderId the folder ID
5877            * @param statuses the statuses
5878            * @return the matching journal articles
5879            * @throws SystemException if a system exception occurred
5880            */
5881            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5882                    long groupId, long folderId, int[] statuses)
5883                    throws com.liferay.portal.kernel.exception.SystemException {
5884                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
5885            }
5886    
5887            /**
5888            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5889            *
5890            * <p>
5891            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5892            * </p>
5893            *
5894            * @param groupId the group ID
5895            * @param folderId the folder ID
5896            * @param statuses the statuses
5897            * @param start the lower bound of the range of journal articles
5898            * @param end the upper bound of the range of journal articles (not inclusive)
5899            * @return the range of matching journal articles
5900            * @throws SystemException if a system exception occurred
5901            */
5902            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5903                    long groupId, long folderId, int[] statuses, int start, int end)
5904                    throws com.liferay.portal.kernel.exception.SystemException {
5905                    return getPersistence()
5906                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
5907            }
5908    
5909            /**
5910            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5911            *
5912            * <p>
5913            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5914            * </p>
5915            *
5916            * @param groupId the group ID
5917            * @param folderId the folder ID
5918            * @param statuses the statuses
5919            * @param start the lower bound of the range of journal articles
5920            * @param end the upper bound of the range of journal articles (not inclusive)
5921            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5922            * @return the ordered range of matching journal articles
5923            * @throws SystemException if a system exception occurred
5924            */
5925            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5926                    long groupId, long folderId, int[] statuses, int start, int end,
5927                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5928                    throws com.liferay.portal.kernel.exception.SystemException {
5929                    return getPersistence()
5930                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
5931                            orderByComparator);
5932            }
5933    
5934            /**
5935            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
5936            *
5937            * @param groupId the group ID
5938            * @param folderId the folder ID
5939            * @param status the status
5940            * @throws SystemException if a system exception occurred
5941            */
5942            public static void removeByG_F_ST(long groupId, long folderId, int status)
5943                    throws com.liferay.portal.kernel.exception.SystemException {
5944                    getPersistence().removeByG_F_ST(groupId, folderId, status);
5945            }
5946    
5947            /**
5948            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5949            *
5950            * @param groupId the group ID
5951            * @param folderId the folder ID
5952            * @param status the status
5953            * @return the number of matching journal articles
5954            * @throws SystemException if a system exception occurred
5955            */
5956            public static int countByG_F_ST(long groupId, long folderId, int status)
5957                    throws com.liferay.portal.kernel.exception.SystemException {
5958                    return getPersistence().countByG_F_ST(groupId, folderId, status);
5959            }
5960    
5961            /**
5962            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5963            *
5964            * @param groupId the group ID
5965            * @param folderId the folder ID
5966            * @param statuses the statuses
5967            * @return the number of matching journal articles
5968            * @throws SystemException if a system exception occurred
5969            */
5970            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
5971                    throws com.liferay.portal.kernel.exception.SystemException {
5972                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
5973            }
5974    
5975            /**
5976            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5977            *
5978            * @param groupId the group ID
5979            * @param folderId the folder ID
5980            * @param status the status
5981            * @return the number of matching journal articles that the user has permission to view
5982            * @throws SystemException if a system exception occurred
5983            */
5984            public static int filterCountByG_F_ST(long groupId, long folderId,
5985                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5986                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
5987            }
5988    
5989            /**
5990            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5991            *
5992            * @param groupId the group ID
5993            * @param folderId the folder ID
5994            * @param statuses the statuses
5995            * @return the number of matching journal articles that the user has permission to view
5996            * @throws SystemException if a system exception occurred
5997            */
5998            public static int filterCountByG_F_ST(long groupId, long folderId,
5999                    int[] statuses)
6000                    throws com.liferay.portal.kernel.exception.SystemException {
6001                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
6002            }
6003    
6004            /**
6005            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6006            *
6007            * @param groupId the group ID
6008            * @param classNameId the class name ID
6009            * @param classPK the class p k
6010            * @return the matching journal articles
6011            * @throws SystemException if a system exception occurred
6012            */
6013            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6014                    long groupId, long classNameId, long classPK)
6015                    throws com.liferay.portal.kernel.exception.SystemException {
6016                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
6017            }
6018    
6019            /**
6020            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6021            *
6022            * <p>
6023            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6024            * </p>
6025            *
6026            * @param groupId the group ID
6027            * @param classNameId the class name ID
6028            * @param classPK the class p k
6029            * @param start the lower bound of the range of journal articles
6030            * @param end the upper bound of the range of journal articles (not inclusive)
6031            * @return the range of matching journal articles
6032            * @throws SystemException if a system exception occurred
6033            */
6034            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6035                    long groupId, long classNameId, long classPK, int start, int end)
6036                    throws com.liferay.portal.kernel.exception.SystemException {
6037                    return getPersistence()
6038                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
6039            }
6040    
6041            /**
6042            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6043            *
6044            * <p>
6045            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6046            * </p>
6047            *
6048            * @param groupId the group ID
6049            * @param classNameId the class name ID
6050            * @param classPK the class p k
6051            * @param start the lower bound of the range of journal articles
6052            * @param end the upper bound of the range of journal articles (not inclusive)
6053            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6054            * @return the ordered range of matching journal articles
6055            * @throws SystemException if a system exception occurred
6056            */
6057            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6058                    long groupId, long classNameId, long classPK, int start, int end,
6059                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6060                    throws com.liferay.portal.kernel.exception.SystemException {
6061                    return getPersistence()
6062                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
6063                            orderByComparator);
6064            }
6065    
6066            /**
6067            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6068            *
6069            * @param groupId the group ID
6070            * @param classNameId the class name ID
6071            * @param classPK the class p k
6072            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6073            * @return the first matching journal article
6074            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6075            * @throws SystemException if a system exception occurred
6076            */
6077            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
6078                    long groupId, long classNameId, long classPK,
6079                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6080                    throws com.liferay.portal.kernel.exception.SystemException,
6081                            com.liferay.portlet.journal.NoSuchArticleException {
6082                    return getPersistence()
6083                                       .findByG_C_C_First(groupId, classNameId, classPK,
6084                            orderByComparator);
6085            }
6086    
6087            /**
6088            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6089            *
6090            * @param groupId the group ID
6091            * @param classNameId the class name ID
6092            * @param classPK the class p k
6093            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6094            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6095            * @throws SystemException if a system exception occurred
6096            */
6097            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
6098                    long groupId, long classNameId, long classPK,
6099                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6100                    throws com.liferay.portal.kernel.exception.SystemException {
6101                    return getPersistence()
6102                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
6103                            orderByComparator);
6104            }
6105    
6106            /**
6107            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6108            *
6109            * @param groupId the group ID
6110            * @param classNameId the class name ID
6111            * @param classPK the class p k
6112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6113            * @return the last matching journal article
6114            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6115            * @throws SystemException if a system exception occurred
6116            */
6117            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
6118                    long groupId, long classNameId, long classPK,
6119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6120                    throws com.liferay.portal.kernel.exception.SystemException,
6121                            com.liferay.portlet.journal.NoSuchArticleException {
6122                    return getPersistence()
6123                                       .findByG_C_C_Last(groupId, classNameId, classPK,
6124                            orderByComparator);
6125            }
6126    
6127            /**
6128            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6129            *
6130            * @param groupId the group ID
6131            * @param classNameId the class name ID
6132            * @param classPK the class p k
6133            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6134            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6135            * @throws SystemException if a system exception occurred
6136            */
6137            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
6138                    long groupId, long classNameId, long classPK,
6139                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6140                    throws com.liferay.portal.kernel.exception.SystemException {
6141                    return getPersistence()
6142                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
6143                            orderByComparator);
6144            }
6145    
6146            /**
6147            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6148            *
6149            * @param id the primary key of the current journal article
6150            * @param groupId the group ID
6151            * @param classNameId the class name ID
6152            * @param classPK the class p k
6153            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6154            * @return the previous, current, and next journal article
6155            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6156            * @throws SystemException if a system exception occurred
6157            */
6158            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
6159                    long id, long groupId, long classNameId, long classPK,
6160                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6161                    throws com.liferay.portal.kernel.exception.SystemException,
6162                            com.liferay.portlet.journal.NoSuchArticleException {
6163                    return getPersistence()
6164                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
6165                            orderByComparator);
6166            }
6167    
6168            /**
6169            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6170            *
6171            * @param groupId the group ID
6172            * @param classNameId the class name ID
6173            * @param classPK the class p k
6174            * @return the matching journal articles that the user has permission to view
6175            * @throws SystemException if a system exception occurred
6176            */
6177            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6178                    long groupId, long classNameId, long classPK)
6179                    throws com.liferay.portal.kernel.exception.SystemException {
6180                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
6181            }
6182    
6183            /**
6184            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6185            *
6186            * <p>
6187            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6188            * </p>
6189            *
6190            * @param groupId the group ID
6191            * @param classNameId the class name ID
6192            * @param classPK the class p k
6193            * @param start the lower bound of the range of journal articles
6194            * @param end the upper bound of the range of journal articles (not inclusive)
6195            * @return the range of matching journal articles that the user has permission to view
6196            * @throws SystemException if a system exception occurred
6197            */
6198            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6199                    long groupId, long classNameId, long classPK, int start, int end)
6200                    throws com.liferay.portal.kernel.exception.SystemException {
6201                    return getPersistence()
6202                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
6203            }
6204    
6205            /**
6206            * 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;.
6207            *
6208            * <p>
6209            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6210            * </p>
6211            *
6212            * @param groupId the group ID
6213            * @param classNameId the class name ID
6214            * @param classPK the class p k
6215            * @param start the lower bound of the range of journal articles
6216            * @param end the upper bound of the range of journal articles (not inclusive)
6217            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6218            * @return the ordered range of matching journal articles that the user has permission to view
6219            * @throws SystemException if a system exception occurred
6220            */
6221            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6222                    long groupId, long classNameId, long classPK, int start, int end,
6223                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6224                    throws com.liferay.portal.kernel.exception.SystemException {
6225                    return getPersistence()
6226                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
6227                            end, orderByComparator);
6228            }
6229    
6230            /**
6231            * 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;.
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 classPK the class p k
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[] filterFindByG_C_C_PrevAndNext(
6243                    long id, long groupId, long classNameId, long classPK,
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                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
6249                            classPK, orderByComparator);
6250            }
6251    
6252            /**
6253            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
6254            *
6255            * @param groupId the group ID
6256            * @param classNameId the class name ID
6257            * @param classPK the class p k
6258            * @throws SystemException if a system exception occurred
6259            */
6260            public static void removeByG_C_C(long groupId, long classNameId,
6261                    long classPK)
6262                    throws com.liferay.portal.kernel.exception.SystemException {
6263                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
6264            }
6265    
6266            /**
6267            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6268            *
6269            * @param groupId the group ID
6270            * @param classNameId the class name ID
6271            * @param classPK the class p k
6272            * @return the number of matching journal articles
6273            * @throws SystemException if a system exception occurred
6274            */
6275            public static int countByG_C_C(long groupId, long classNameId, long classPK)
6276                    throws com.liferay.portal.kernel.exception.SystemException {
6277                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
6278            }
6279    
6280            /**
6281            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6282            *
6283            * @param groupId the group ID
6284            * @param classNameId the class name ID
6285            * @param classPK the class p k
6286            * @return the number of matching journal articles that the user has permission to view
6287            * @throws SystemException if a system exception occurred
6288            */
6289            public static int filterCountByG_C_C(long groupId, long classNameId,
6290                    long classPK)
6291                    throws com.liferay.portal.kernel.exception.SystemException {
6292                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
6293            }
6294    
6295            /**
6296            * 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.
6297            *
6298            * @param groupId the group ID
6299            * @param classNameId the class name ID
6300            * @param structureId the structure ID
6301            * @return the matching journal article
6302            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6303            * @throws SystemException if a system exception occurred
6304            */
6305            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
6306                    long groupId, long classNameId, java.lang.String structureId)
6307                    throws com.liferay.portal.kernel.exception.SystemException,
6308                            com.liferay.portlet.journal.NoSuchArticleException {
6309                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
6310            }
6311    
6312            /**
6313            * 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.
6314            *
6315            * @param groupId the group ID
6316            * @param classNameId the class name ID
6317            * @param structureId the structure ID
6318            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6319            * @throws SystemException if a system exception occurred
6320            */
6321            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6322                    long groupId, long classNameId, java.lang.String structureId)
6323                    throws com.liferay.portal.kernel.exception.SystemException {
6324                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
6325            }
6326    
6327            /**
6328            * 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.
6329            *
6330            * @param groupId the group ID
6331            * @param classNameId the class name ID
6332            * @param structureId the structure ID
6333            * @param retrieveFromCache whether to use the finder cache
6334            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6335            * @throws SystemException if a system exception occurred
6336            */
6337            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6338                    long groupId, long classNameId, java.lang.String structureId,
6339                    boolean retrieveFromCache)
6340                    throws com.liferay.portal.kernel.exception.SystemException {
6341                    return getPersistence()
6342                                       .fetchByG_C_S(groupId, classNameId, structureId,
6343                            retrieveFromCache);
6344            }
6345    
6346            /**
6347            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
6348            *
6349            * @param groupId the group ID
6350            * @param classNameId the class name ID
6351            * @param structureId the structure ID
6352            * @return the journal article that was removed
6353            * @throws SystemException if a system exception occurred
6354            */
6355            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
6356                    long groupId, long classNameId, java.lang.String structureId)
6357                    throws com.liferay.portal.kernel.exception.SystemException,
6358                            com.liferay.portlet.journal.NoSuchArticleException {
6359                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
6360            }
6361    
6362            /**
6363            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
6364            *
6365            * @param groupId the group ID
6366            * @param classNameId the class name ID
6367            * @param structureId the structure ID
6368            * @return the number of matching journal articles
6369            * @throws SystemException if a system exception occurred
6370            */
6371            public static int countByG_C_S(long groupId, long classNameId,
6372                    java.lang.String structureId)
6373                    throws com.liferay.portal.kernel.exception.SystemException {
6374                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
6375            }
6376    
6377            /**
6378            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6379            *
6380            * @param groupId the group ID
6381            * @param classNameId the class name ID
6382            * @param templateId the template ID
6383            * @return the matching journal articles
6384            * @throws SystemException if a system exception occurred
6385            */
6386            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6387                    long groupId, long classNameId, java.lang.String templateId)
6388                    throws com.liferay.portal.kernel.exception.SystemException {
6389                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
6390            }
6391    
6392            /**
6393            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6394            *
6395            * <p>
6396            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6397            * </p>
6398            *
6399            * @param groupId the group ID
6400            * @param classNameId the class name ID
6401            * @param templateId the template ID
6402            * @param start the lower bound of the range of journal articles
6403            * @param end the upper bound of the range of journal articles (not inclusive)
6404            * @return the range of matching journal articles
6405            * @throws SystemException if a system exception occurred
6406            */
6407            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6408                    long groupId, long classNameId, java.lang.String templateId, int start,
6409                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6410                    return getPersistence()
6411                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
6412            }
6413    
6414            /**
6415            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6416            *
6417            * <p>
6418            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6419            * </p>
6420            *
6421            * @param groupId the group ID
6422            * @param classNameId the class name ID
6423            * @param templateId the template ID
6424            * @param start the lower bound of the range of journal articles
6425            * @param end the upper bound of the range of journal articles (not inclusive)
6426            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6427            * @return the ordered range of matching journal articles
6428            * @throws SystemException if a system exception occurred
6429            */
6430            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6431                    long groupId, long classNameId, java.lang.String templateId, int start,
6432                    int end,
6433                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6434                    throws com.liferay.portal.kernel.exception.SystemException {
6435                    return getPersistence()
6436                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
6437                            orderByComparator);
6438            }
6439    
6440            /**
6441            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6442            *
6443            * @param groupId the group ID
6444            * @param classNameId the class name ID
6445            * @param templateId the template ID
6446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6447            * @return the first matching journal article
6448            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6449            * @throws SystemException if a system exception occurred
6450            */
6451            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
6452                    long groupId, long classNameId, java.lang.String templateId,
6453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6454                    throws com.liferay.portal.kernel.exception.SystemException,
6455                            com.liferay.portlet.journal.NoSuchArticleException {
6456                    return getPersistence()
6457                                       .findByG_C_T_First(groupId, classNameId, templateId,
6458                            orderByComparator);
6459            }
6460    
6461            /**
6462            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6463            *
6464            * @param groupId the group ID
6465            * @param classNameId the class name ID
6466            * @param templateId the template ID
6467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6468            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6469            * @throws SystemException if a system exception occurred
6470            */
6471            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
6472                    long groupId, long classNameId, java.lang.String templateId,
6473                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6474                    throws com.liferay.portal.kernel.exception.SystemException {
6475                    return getPersistence()
6476                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
6477                            orderByComparator);
6478            }
6479    
6480            /**
6481            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6482            *
6483            * @param groupId the group ID
6484            * @param classNameId the class name ID
6485            * @param templateId the template ID
6486            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6487            * @return the last matching journal article
6488            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6489            * @throws SystemException if a system exception occurred
6490            */
6491            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
6492                    long groupId, long classNameId, java.lang.String templateId,
6493                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6494                    throws com.liferay.portal.kernel.exception.SystemException,
6495                            com.liferay.portlet.journal.NoSuchArticleException {
6496                    return getPersistence()
6497                                       .findByG_C_T_Last(groupId, classNameId, templateId,
6498                            orderByComparator);
6499            }
6500    
6501            /**
6502            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6503            *
6504            * @param groupId the group ID
6505            * @param classNameId the class name ID
6506            * @param templateId the template ID
6507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6508            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6509            * @throws SystemException if a system exception occurred
6510            */
6511            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
6512                    long groupId, long classNameId, java.lang.String templateId,
6513                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6514                    throws com.liferay.portal.kernel.exception.SystemException {
6515                    return getPersistence()
6516                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
6517                            orderByComparator);
6518            }
6519    
6520            /**
6521            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6522            *
6523            * @param id the primary key of the current journal article
6524            * @param groupId the group ID
6525            * @param classNameId the class name ID
6526            * @param templateId the template ID
6527            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6528            * @return the previous, current, and next journal article
6529            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6530            * @throws SystemException if a system exception occurred
6531            */
6532            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
6533                    long id, long groupId, long classNameId, java.lang.String templateId,
6534                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6535                    throws com.liferay.portal.kernel.exception.SystemException,
6536                            com.liferay.portlet.journal.NoSuchArticleException {
6537                    return getPersistence()
6538                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
6539                            templateId, orderByComparator);
6540            }
6541    
6542            /**
6543            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6544            *
6545            * @param groupId the group ID
6546            * @param classNameId the class name ID
6547            * @param templateId the template ID
6548            * @return the matching journal articles that the user has permission to view
6549            * @throws SystemException if a system exception occurred
6550            */
6551            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6552                    long groupId, long classNameId, java.lang.String templateId)
6553                    throws com.liferay.portal.kernel.exception.SystemException {
6554                    return getPersistence()
6555                                       .filterFindByG_C_T(groupId, classNameId, templateId);
6556            }
6557    
6558            /**
6559            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6560            *
6561            * <p>
6562            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6563            * </p>
6564            *
6565            * @param groupId the group ID
6566            * @param classNameId the class name ID
6567            * @param templateId the template ID
6568            * @param start the lower bound of the range of journal articles
6569            * @param end the upper bound of the range of journal articles (not inclusive)
6570            * @return the range of matching journal articles that the user has permission to view
6571            * @throws SystemException if a system exception occurred
6572            */
6573            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6574                    long groupId, long classNameId, java.lang.String templateId, int start,
6575                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6576                    return getPersistence()
6577                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6578                            end);
6579            }
6580    
6581            /**
6582            * 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;.
6583            *
6584            * <p>
6585            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6586            * </p>
6587            *
6588            * @param groupId the group ID
6589            * @param classNameId the class name ID
6590            * @param templateId the template ID
6591            * @param start the lower bound of the range of journal articles
6592            * @param end the upper bound of the range of journal articles (not inclusive)
6593            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6594            * @return the ordered range of matching journal articles that the user has permission to view
6595            * @throws SystemException if a system exception occurred
6596            */
6597            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6598                    long groupId, long classNameId, java.lang.String templateId, int start,
6599                    int end,
6600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6601                    throws com.liferay.portal.kernel.exception.SystemException {
6602                    return getPersistence()
6603                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6604                            end, orderByComparator);
6605            }
6606    
6607            /**
6608            * 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;.
6609            *
6610            * @param id the primary key of the current journal article
6611            * @param groupId the group ID
6612            * @param classNameId the class name ID
6613            * @param templateId the template ID
6614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6615            * @return the previous, current, and next journal article
6616            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6617            * @throws SystemException if a system exception occurred
6618            */
6619            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
6620                    long id, long groupId, long classNameId, java.lang.String templateId,
6621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6622                    throws com.liferay.portal.kernel.exception.SystemException,
6623                            com.liferay.portlet.journal.NoSuchArticleException {
6624                    return getPersistence()
6625                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
6626                            templateId, orderByComparator);
6627            }
6628    
6629            /**
6630            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
6631            *
6632            * @param groupId the group ID
6633            * @param classNameId the class name ID
6634            * @param templateId the template ID
6635            * @throws SystemException if a system exception occurred
6636            */
6637            public static void removeByG_C_T(long groupId, long classNameId,
6638                    java.lang.String templateId)
6639                    throws com.liferay.portal.kernel.exception.SystemException {
6640                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
6641            }
6642    
6643            /**
6644            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6645            *
6646            * @param groupId the group ID
6647            * @param classNameId the class name ID
6648            * @param templateId the template ID
6649            * @return the number of matching journal articles
6650            * @throws SystemException if a system exception occurred
6651            */
6652            public static int countByG_C_T(long groupId, long classNameId,
6653                    java.lang.String templateId)
6654                    throws com.liferay.portal.kernel.exception.SystemException {
6655                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
6656            }
6657    
6658            /**
6659            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6660            *
6661            * @param groupId the group ID
6662            * @param classNameId the class name ID
6663            * @param templateId the template ID
6664            * @return the number of matching journal articles that the user has permission to view
6665            * @throws SystemException if a system exception occurred
6666            */
6667            public static int filterCountByG_C_T(long groupId, long classNameId,
6668                    java.lang.String templateId)
6669                    throws com.liferay.portal.kernel.exception.SystemException {
6670                    return getPersistence()
6671                                       .filterCountByG_C_T(groupId, classNameId, templateId);
6672            }
6673    
6674            /**
6675            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6676            *
6677            * @param groupId the group ID
6678            * @param classNameId the class name ID
6679            * @param layoutUuid the layout uuid
6680            * @return the matching journal articles
6681            * @throws SystemException if a system exception occurred
6682            */
6683            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6684                    long groupId, long classNameId, java.lang.String layoutUuid)
6685                    throws com.liferay.portal.kernel.exception.SystemException {
6686                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
6687            }
6688    
6689            /**
6690            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6691            *
6692            * <p>
6693            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6694            * </p>
6695            *
6696            * @param groupId the group ID
6697            * @param classNameId the class name ID
6698            * @param layoutUuid the layout uuid
6699            * @param start the lower bound of the range of journal articles
6700            * @param end the upper bound of the range of journal articles (not inclusive)
6701            * @return the range of matching journal articles
6702            * @throws SystemException if a system exception occurred
6703            */
6704            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6705                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6706                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6707                    return getPersistence()
6708                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6709            }
6710    
6711            /**
6712            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6713            *
6714            * <p>
6715            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6716            * </p>
6717            *
6718            * @param groupId the group ID
6719            * @param classNameId the class name ID
6720            * @param layoutUuid the layout uuid
6721            * @param start the lower bound of the range of journal articles
6722            * @param end the upper bound of the range of journal articles (not inclusive)
6723            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6724            * @return the ordered range of matching journal articles
6725            * @throws SystemException if a system exception occurred
6726            */
6727            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6728                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6729                    int end,
6730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6731                    throws com.liferay.portal.kernel.exception.SystemException {
6732                    return getPersistence()
6733                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6734                            orderByComparator);
6735            }
6736    
6737            /**
6738            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6739            *
6740            * @param groupId the group ID
6741            * @param classNameId the class name ID
6742            * @param layoutUuid the layout uuid
6743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6744            * @return the first matching journal article
6745            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6746            * @throws SystemException if a system exception occurred
6747            */
6748            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
6749                    long groupId, long classNameId, java.lang.String layoutUuid,
6750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6751                    throws com.liferay.portal.kernel.exception.SystemException,
6752                            com.liferay.portlet.journal.NoSuchArticleException {
6753                    return getPersistence()
6754                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
6755                            orderByComparator);
6756            }
6757    
6758            /**
6759            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6760            *
6761            * @param groupId the group ID
6762            * @param classNameId the class name ID
6763            * @param layoutUuid the layout uuid
6764            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6765            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6766            * @throws SystemException if a system exception occurred
6767            */
6768            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
6769                    long groupId, long classNameId, java.lang.String layoutUuid,
6770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6771                    throws com.liferay.portal.kernel.exception.SystemException {
6772                    return getPersistence()
6773                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
6774                            orderByComparator);
6775            }
6776    
6777            /**
6778            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6779            *
6780            * @param groupId the group ID
6781            * @param classNameId the class name ID
6782            * @param layoutUuid the layout uuid
6783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6784            * @return the last matching journal article
6785            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6786            * @throws SystemException if a system exception occurred
6787            */
6788            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
6789                    long groupId, long classNameId, java.lang.String layoutUuid,
6790                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6791                    throws com.liferay.portal.kernel.exception.SystemException,
6792                            com.liferay.portlet.journal.NoSuchArticleException {
6793                    return getPersistence()
6794                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
6795                            orderByComparator);
6796            }
6797    
6798            /**
6799            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6800            *
6801            * @param groupId the group ID
6802            * @param classNameId the class name ID
6803            * @param layoutUuid the layout uuid
6804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6805            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6806            * @throws SystemException if a system exception occurred
6807            */
6808            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
6809                    long groupId, long classNameId, java.lang.String layoutUuid,
6810                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6811                    throws com.liferay.portal.kernel.exception.SystemException {
6812                    return getPersistence()
6813                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
6814                            orderByComparator);
6815            }
6816    
6817            /**
6818            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6819            *
6820            * @param id the primary key of the current journal article
6821            * @param groupId the group ID
6822            * @param classNameId the class name ID
6823            * @param layoutUuid the layout uuid
6824            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6825            * @return the previous, current, and next journal article
6826            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6827            * @throws SystemException if a system exception occurred
6828            */
6829            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
6830                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6832                    throws com.liferay.portal.kernel.exception.SystemException,
6833                            com.liferay.portlet.journal.NoSuchArticleException {
6834                    return getPersistence()
6835                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
6836                            layoutUuid, orderByComparator);
6837            }
6838    
6839            /**
6840            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6841            *
6842            * @param groupId the group ID
6843            * @param classNameId the class name ID
6844            * @param layoutUuid the layout uuid
6845            * @return the matching journal articles that the user has permission to view
6846            * @throws SystemException if a system exception occurred
6847            */
6848            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6849                    long groupId, long classNameId, java.lang.String layoutUuid)
6850                    throws com.liferay.portal.kernel.exception.SystemException {
6851                    return getPersistence()
6852                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
6853            }
6854    
6855            /**
6856            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6857            *
6858            * <p>
6859            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6860            * </p>
6861            *
6862            * @param groupId the group ID
6863            * @param classNameId the class name ID
6864            * @param layoutUuid the layout uuid
6865            * @param start the lower bound of the range of journal articles
6866            * @param end the upper bound of the range of journal articles (not inclusive)
6867            * @return the range of matching journal articles that the user has permission to view
6868            * @throws SystemException if a system exception occurred
6869            */
6870            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6871                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6872                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6873                    return getPersistence()
6874                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6875                            end);
6876            }
6877    
6878            /**
6879            * 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;.
6880            *
6881            * <p>
6882            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6883            * </p>
6884            *
6885            * @param groupId the group ID
6886            * @param classNameId the class name ID
6887            * @param layoutUuid the layout uuid
6888            * @param start the lower bound of the range of journal articles
6889            * @param end the upper bound of the range of journal articles (not inclusive)
6890            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6891            * @return the ordered range of matching journal articles that the user has permission to view
6892            * @throws SystemException if a system exception occurred
6893            */
6894            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6895                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6896                    int end,
6897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6898                    throws com.liferay.portal.kernel.exception.SystemException {
6899                    return getPersistence()
6900                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6901                            end, orderByComparator);
6902            }
6903    
6904            /**
6905            * 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;.
6906            *
6907            * @param id the primary key of the current journal article
6908            * @param groupId the group ID
6909            * @param classNameId the class name ID
6910            * @param layoutUuid the layout uuid
6911            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6912            * @return the previous, current, and next journal article
6913            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6914            * @throws SystemException if a system exception occurred
6915            */
6916            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
6917                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6918                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6919                    throws com.liferay.portal.kernel.exception.SystemException,
6920                            com.liferay.portlet.journal.NoSuchArticleException {
6921                    return getPersistence()
6922                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6923                            layoutUuid, orderByComparator);
6924            }
6925    
6926            /**
6927            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6928            *
6929            * @param groupId the group ID
6930            * @param classNameId the class name ID
6931            * @param layoutUuid the layout uuid
6932            * @throws SystemException if a system exception occurred
6933            */
6934            public static void removeByG_C_L(long groupId, long classNameId,
6935                    java.lang.String layoutUuid)
6936                    throws com.liferay.portal.kernel.exception.SystemException {
6937                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6938            }
6939    
6940            /**
6941            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6942            *
6943            * @param groupId the group ID
6944            * @param classNameId the class name ID
6945            * @param layoutUuid the layout uuid
6946            * @return the number of matching journal articles
6947            * @throws SystemException if a system exception occurred
6948            */
6949            public static int countByG_C_L(long groupId, long classNameId,
6950                    java.lang.String layoutUuid)
6951                    throws com.liferay.portal.kernel.exception.SystemException {
6952                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6953            }
6954    
6955            /**
6956            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6957            *
6958            * @param groupId the group ID
6959            * @param classNameId the class name ID
6960            * @param layoutUuid the layout uuid
6961            * @return the number of matching journal articles that the user has permission to view
6962            * @throws SystemException if a system exception occurred
6963            */
6964            public static int filterCountByG_C_L(long groupId, long classNameId,
6965                    java.lang.String layoutUuid)
6966                    throws com.liferay.portal.kernel.exception.SystemException {
6967                    return getPersistence()
6968                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
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    }