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 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 displayDate &lt; &#63; and status = &#63;.
4643            *
4644            * @param displayDate the display date
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> findByLtD_S(
4650                    java.util.Date displayDate, int status)
4651                    throws com.liferay.portal.kernel.exception.SystemException {
4652                    return getPersistence().findByLtD_S(displayDate, status);
4653            }
4654    
4655            /**
4656            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#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 displayDate the display date
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> findByLtD_S(
4670                    java.util.Date displayDate, int status, int start, int end)
4671                    throws com.liferay.portal.kernel.exception.SystemException {
4672                    return getPersistence().findByLtD_S(displayDate, status, start, end);
4673            }
4674    
4675            /**
4676            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#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 displayDate the display date
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> findByLtD_S(
4691                    java.util.Date displayDate, 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                                       .findByLtD_S(displayDate, status, start, end,
4696                            orderByComparator);
4697            }
4698    
4699            /**
4700            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4701            *
4702            * @param displayDate the display date
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 findByLtD_S_First(
4710                    java.util.Date displayDate, 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                                       .findByLtD_S_First(displayDate, status, orderByComparator);
4716            }
4717    
4718            /**
4719            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4720            *
4721            * @param displayDate the display date
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 fetchByLtD_S_First(
4728                    java.util.Date displayDate, int status,
4729                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4730                    throws com.liferay.portal.kernel.exception.SystemException {
4731                    return getPersistence()
4732                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
4733            }
4734    
4735            /**
4736            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4737            *
4738            * @param displayDate the display date
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 findByLtD_S_Last(
4746                    java.util.Date displayDate, 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                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
4752            }
4753    
4754            /**
4755            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4756            *
4757            * @param displayDate the display date
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 fetchByLtD_S_Last(
4764                    java.util.Date displayDate, int status,
4765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4766                    throws com.liferay.portal.kernel.exception.SystemException {
4767                    return getPersistence()
4768                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
4769            }
4770    
4771            /**
4772            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4773            *
4774            * @param id the primary key of the current journal article
4775            * @param displayDate the display date
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[] findByLtD_S_PrevAndNext(
4783                    long id, java.util.Date displayDate, 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                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
4789                            orderByComparator);
4790            }
4791    
4792            /**
4793            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
4794            *
4795            * @param displayDate the display date
4796            * @param status the status
4797            * @throws SystemException if a system exception occurred
4798            */
4799            public static void removeByLtD_S(java.util.Date displayDate, int status)
4800                    throws com.liferay.portal.kernel.exception.SystemException {
4801                    getPersistence().removeByLtD_S(displayDate, status);
4802            }
4803    
4804            /**
4805            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
4806            *
4807            * @param displayDate the display date
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 countByLtD_S(java.util.Date displayDate, int status)
4813                    throws com.liferay.portal.kernel.exception.SystemException {
4814                    return getPersistence().countByLtD_S(displayDate, status);
4815            }
4816    
4817            /**
4818            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4819            *
4820            * @param resourcePrimKey the resource prim key
4821            * @param indexable the indexable
4822            * @param status the status
4823            * @return the matching journal articles
4824            * @throws SystemException if a system exception occurred
4825            */
4826            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4827                    long resourcePrimKey, boolean indexable, int status)
4828                    throws com.liferay.portal.kernel.exception.SystemException {
4829                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
4830            }
4831    
4832            /**
4833            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4834            *
4835            * <p>
4836            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4837            * </p>
4838            *
4839            * @param resourcePrimKey the resource prim key
4840            * @param indexable the indexable
4841            * @param status the status
4842            * @param start the lower bound of the range of journal articles
4843            * @param end the upper bound of the range of journal articles (not inclusive)
4844            * @return the range of matching journal articles
4845            * @throws SystemException if a system exception occurred
4846            */
4847            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4848                    long resourcePrimKey, boolean indexable, int status, int start, int end)
4849                    throws com.liferay.portal.kernel.exception.SystemException {
4850                    return getPersistence()
4851                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
4852            }
4853    
4854            /**
4855            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4856            *
4857            * <p>
4858            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4859            * </p>
4860            *
4861            * @param resourcePrimKey the resource prim key
4862            * @param indexable the indexable
4863            * @param status the status
4864            * @param start the lower bound of the range of journal articles
4865            * @param end the upper bound of the range of journal articles (not inclusive)
4866            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4867            * @return the ordered range of matching journal articles
4868            * @throws SystemException if a system exception occurred
4869            */
4870            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4871                    long resourcePrimKey, boolean indexable, int status, int start,
4872                    int end,
4873                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4874                    throws com.liferay.portal.kernel.exception.SystemException {
4875                    return getPersistence()
4876                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
4877                            orderByComparator);
4878            }
4879    
4880            /**
4881            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4882            *
4883            * @param resourcePrimKey the resource prim key
4884            * @param indexable the indexable
4885            * @param status the status
4886            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4887            * @return the first matching journal article
4888            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4889            * @throws SystemException if a system exception occurred
4890            */
4891            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First(
4892                    long resourcePrimKey, boolean indexable, int status,
4893                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4894                    throws com.liferay.portal.kernel.exception.SystemException,
4895                            com.liferay.portlet.journal.NoSuchArticleException {
4896                    return getPersistence()
4897                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
4898                            orderByComparator);
4899            }
4900    
4901            /**
4902            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4903            *
4904            * @param resourcePrimKey the resource prim key
4905            * @param indexable the indexable
4906            * @param status the status
4907            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4908            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4909            * @throws SystemException if a system exception occurred
4910            */
4911            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First(
4912                    long resourcePrimKey, boolean indexable, int status,
4913                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4914                    throws com.liferay.portal.kernel.exception.SystemException {
4915                    return getPersistence()
4916                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
4917                            orderByComparator);
4918            }
4919    
4920            /**
4921            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4922            *
4923            * @param resourcePrimKey the resource prim key
4924            * @param indexable the indexable
4925            * @param status the status
4926            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4927            * @return the last matching journal article
4928            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4929            * @throws SystemException if a system exception occurred
4930            */
4931            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last(
4932                    long resourcePrimKey, boolean indexable, int status,
4933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4934                    throws com.liferay.portal.kernel.exception.SystemException,
4935                            com.liferay.portlet.journal.NoSuchArticleException {
4936                    return getPersistence()
4937                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
4938                            orderByComparator);
4939            }
4940    
4941            /**
4942            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4943            *
4944            * @param resourcePrimKey the resource prim key
4945            * @param indexable the indexable
4946            * @param status the status
4947            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4948            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4949            * @throws SystemException if a system exception occurred
4950            */
4951            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last(
4952                    long resourcePrimKey, boolean indexable, int status,
4953                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4954                    throws com.liferay.portal.kernel.exception.SystemException {
4955                    return getPersistence()
4956                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
4957                            orderByComparator);
4958            }
4959    
4960            /**
4961            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4962            *
4963            * @param id the primary key of the current journal article
4964            * @param resourcePrimKey the resource prim key
4965            * @param indexable the indexable
4966            * @param status the status
4967            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4968            * @return the previous, current, and next journal article
4969            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4970            * @throws SystemException if a system exception occurred
4971            */
4972            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext(
4973                    long id, long resourcePrimKey, boolean indexable, int status,
4974                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4975                    throws com.liferay.portal.kernel.exception.SystemException,
4976                            com.liferay.portlet.journal.NoSuchArticleException {
4977                    return getPersistence()
4978                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
4979                            status, orderByComparator);
4980            }
4981    
4982            /**
4983            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4984            *
4985            * <p>
4986            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4987            * </p>
4988            *
4989            * @param resourcePrimKey the resource prim key
4990            * @param indexable the indexable
4991            * @param statuses the statuses
4992            * @return the matching journal articles
4993            * @throws SystemException if a system exception occurred
4994            */
4995            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4996                    long resourcePrimKey, boolean indexable, int[] statuses)
4997                    throws com.liferay.portal.kernel.exception.SystemException {
4998                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
4999            }
5000    
5001            /**
5002            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5003            *
5004            * <p>
5005            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5006            * </p>
5007            *
5008            * @param resourcePrimKey the resource prim key
5009            * @param indexable the indexable
5010            * @param statuses the statuses
5011            * @param start the lower bound of the range of journal articles
5012            * @param end the upper bound of the range of journal articles (not inclusive)
5013            * @return the range of matching journal articles
5014            * @throws SystemException if a system exception occurred
5015            */
5016            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5017                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5018                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5019                    return getPersistence()
5020                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
5021            }
5022    
5023            /**
5024            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5025            *
5026            * <p>
5027            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5028            * </p>
5029            *
5030            * @param resourcePrimKey the resource prim key
5031            * @param indexable the indexable
5032            * @param statuses the statuses
5033            * @param start the lower bound of the range of journal articles
5034            * @param end the upper bound of the range of journal articles (not inclusive)
5035            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5036            * @return the ordered range of matching journal articles
5037            * @throws SystemException if a system exception occurred
5038            */
5039            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5040                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5041                    int end,
5042                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5043                    throws com.liferay.portal.kernel.exception.SystemException {
5044                    return getPersistence()
5045                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
5046                            end, orderByComparator);
5047            }
5048    
5049            /**
5050            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
5051            *
5052            * @param resourcePrimKey the resource prim key
5053            * @param indexable the indexable
5054            * @param status the status
5055            * @throws SystemException if a system exception occurred
5056            */
5057            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
5058                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5059                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
5060            }
5061    
5062            /**
5063            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5064            *
5065            * @param resourcePrimKey the resource prim key
5066            * @param indexable the indexable
5067            * @param status the status
5068            * @return the number of matching journal articles
5069            * @throws SystemException if a system exception occurred
5070            */
5071            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5072                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5073                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
5074            }
5075    
5076            /**
5077            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5078            *
5079            * @param resourcePrimKey the resource prim key
5080            * @param indexable the indexable
5081            * @param statuses the statuses
5082            * @return the number of matching journal articles
5083            * @throws SystemException if a system exception occurred
5084            */
5085            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5086                    int[] statuses)
5087                    throws com.liferay.portal.kernel.exception.SystemException {
5088                    return getPersistence()
5089                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
5090            }
5091    
5092            /**
5093            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5094            *
5095            * @param groupId the group ID
5096            * @param folderId the folder ID
5097            * @param status the status
5098            * @return the matching journal articles
5099            * @throws SystemException if a system exception occurred
5100            */
5101            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5102                    long groupId, long folderId, int status)
5103                    throws com.liferay.portal.kernel.exception.SystemException {
5104                    return getPersistence().findByG_F_ST(groupId, folderId, status);
5105            }
5106    
5107            /**
5108            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5109            *
5110            * <p>
5111            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5112            * </p>
5113            *
5114            * @param groupId the group ID
5115            * @param folderId the folder ID
5116            * @param status the status
5117            * @param start the lower bound of the range of journal articles
5118            * @param end the upper bound of the range of journal articles (not inclusive)
5119            * @return the range of matching journal articles
5120            * @throws SystemException if a system exception occurred
5121            */
5122            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5123                    long groupId, long folderId, int status, int start, int end)
5124                    throws com.liferay.portal.kernel.exception.SystemException {
5125                    return getPersistence()
5126                                       .findByG_F_ST(groupId, folderId, status, start, end);
5127            }
5128    
5129            /**
5130            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5131            *
5132            * <p>
5133            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5134            * </p>
5135            *
5136            * @param groupId the group ID
5137            * @param folderId the folder ID
5138            * @param status the status
5139            * @param start the lower bound of the range of journal articles
5140            * @param end the upper bound of the range of journal articles (not inclusive)
5141            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5142            * @return the ordered range of matching journal articles
5143            * @throws SystemException if a system exception occurred
5144            */
5145            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5146                    long groupId, long folderId, int status, int start, int end,
5147                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5148                    throws com.liferay.portal.kernel.exception.SystemException {
5149                    return getPersistence()
5150                                       .findByG_F_ST(groupId, folderId, status, start, end,
5151                            orderByComparator);
5152            }
5153    
5154            /**
5155            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5156            *
5157            * @param groupId the group ID
5158            * @param folderId the folder ID
5159            * @param status the status
5160            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5161            * @return the first matching journal article
5162            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5163            * @throws SystemException if a system exception occurred
5164            */
5165            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
5166                    long groupId, long folderId, int status,
5167                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5168                    throws com.liferay.portal.kernel.exception.SystemException,
5169                            com.liferay.portlet.journal.NoSuchArticleException {
5170                    return getPersistence()
5171                                       .findByG_F_ST_First(groupId, folderId, status,
5172                            orderByComparator);
5173            }
5174    
5175            /**
5176            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5177            *
5178            * @param groupId the group ID
5179            * @param folderId the folder ID
5180            * @param status the status
5181            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5182            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5183            * @throws SystemException if a system exception occurred
5184            */
5185            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
5186                    long groupId, long folderId, int status,
5187                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5188                    throws com.liferay.portal.kernel.exception.SystemException {
5189                    return getPersistence()
5190                                       .fetchByG_F_ST_First(groupId, folderId, status,
5191                            orderByComparator);
5192            }
5193    
5194            /**
5195            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5196            *
5197            * @param groupId the group ID
5198            * @param folderId the folder ID
5199            * @param status the status
5200            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5201            * @return the last matching journal article
5202            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5203            * @throws SystemException if a system exception occurred
5204            */
5205            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
5206                    long groupId, long folderId, int status,
5207                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5208                    throws com.liferay.portal.kernel.exception.SystemException,
5209                            com.liferay.portlet.journal.NoSuchArticleException {
5210                    return getPersistence()
5211                                       .findByG_F_ST_Last(groupId, folderId, status,
5212                            orderByComparator);
5213            }
5214    
5215            /**
5216            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5217            *
5218            * @param groupId the group ID
5219            * @param folderId the folder ID
5220            * @param status the status
5221            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5222            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5223            * @throws SystemException if a system exception occurred
5224            */
5225            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
5226                    long groupId, long folderId, int status,
5227                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5228                    throws com.liferay.portal.kernel.exception.SystemException {
5229                    return getPersistence()
5230                                       .fetchByG_F_ST_Last(groupId, folderId, status,
5231                            orderByComparator);
5232            }
5233    
5234            /**
5235            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5236            *
5237            * @param id the primary key of the current journal article
5238            * @param groupId the group ID
5239            * @param folderId the folder ID
5240            * @param status the status
5241            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5242            * @return the previous, current, and next journal article
5243            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5244            * @throws SystemException if a system exception occurred
5245            */
5246            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
5247                    long id, long groupId, long folderId, int status,
5248                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5249                    throws com.liferay.portal.kernel.exception.SystemException,
5250                            com.liferay.portlet.journal.NoSuchArticleException {
5251                    return getPersistence()
5252                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
5253                            orderByComparator);
5254            }
5255    
5256            /**
5257            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5258            *
5259            * @param groupId the group ID
5260            * @param folderId the folder ID
5261            * @param status the status
5262            * @return the matching journal articles that the user has permission to view
5263            * @throws SystemException if a system exception occurred
5264            */
5265            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5266                    long groupId, long folderId, int status)
5267                    throws com.liferay.portal.kernel.exception.SystemException {
5268                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
5269            }
5270    
5271            /**
5272            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5273            *
5274            * <p>
5275            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5276            * </p>
5277            *
5278            * @param groupId the group ID
5279            * @param folderId the folder ID
5280            * @param status the status
5281            * @param start the lower bound of the range of journal articles
5282            * @param end the upper bound of the range of journal articles (not inclusive)
5283            * @return the range of matching journal articles that the user has permission to view
5284            * @throws SystemException if a system exception occurred
5285            */
5286            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5287                    long groupId, long folderId, int status, int start, int end)
5288                    throws com.liferay.portal.kernel.exception.SystemException {
5289                    return getPersistence()
5290                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
5291            }
5292    
5293            /**
5294            * 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;.
5295            *
5296            * <p>
5297            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5298            * </p>
5299            *
5300            * @param groupId the group ID
5301            * @param folderId the folder ID
5302            * @param status the status
5303            * @param start the lower bound of the range of journal articles
5304            * @param end the upper bound of the range of journal articles (not inclusive)
5305            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5306            * @return the ordered range of matching journal articles that the user has permission to view
5307            * @throws SystemException if a system exception occurred
5308            */
5309            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5310                    long groupId, long folderId, int status, int start, int end,
5311                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5312                    throws com.liferay.portal.kernel.exception.SystemException {
5313                    return getPersistence()
5314                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
5315                            orderByComparator);
5316            }
5317    
5318            /**
5319            * 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;.
5320            *
5321            * @param id the primary key of the current journal article
5322            * @param groupId the group ID
5323            * @param folderId the folder ID
5324            * @param status the status
5325            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5326            * @return the previous, current, and next journal article
5327            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5328            * @throws SystemException if a system exception occurred
5329            */
5330            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
5331                    long id, long groupId, long folderId, int status,
5332                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5333                    throws com.liferay.portal.kernel.exception.SystemException,
5334                            com.liferay.portlet.journal.NoSuchArticleException {
5335                    return getPersistence()
5336                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
5337                            status, orderByComparator);
5338            }
5339    
5340            /**
5341            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5342            *
5343            * @param groupId the group ID
5344            * @param folderId the folder ID
5345            * @param statuses the statuses
5346            * @return the matching journal articles that the user has permission to view
5347            * @throws SystemException if a system exception occurred
5348            */
5349            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5350                    long groupId, long folderId, int[] statuses)
5351                    throws com.liferay.portal.kernel.exception.SystemException {
5352                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
5353            }
5354    
5355            /**
5356            * 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;.
5357            *
5358            * <p>
5359            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5360            * </p>
5361            *
5362            * @param groupId the group ID
5363            * @param folderId the folder ID
5364            * @param statuses the statuses
5365            * @param start the lower bound of the range of journal articles
5366            * @param end the upper bound of the range of journal articles (not inclusive)
5367            * @return the range of matching journal articles that the user has permission to view
5368            * @throws SystemException if a system exception occurred
5369            */
5370            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5371                    long groupId, long folderId, int[] statuses, int start, int end)
5372                    throws com.liferay.portal.kernel.exception.SystemException {
5373                    return getPersistence()
5374                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
5375            }
5376    
5377            /**
5378            * 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;.
5379            *
5380            * <p>
5381            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5382            * </p>
5383            *
5384            * @param groupId the group ID
5385            * @param folderId the folder ID
5386            * @param statuses the statuses
5387            * @param start the lower bound of the range of journal articles
5388            * @param end the upper bound of the range of journal articles (not inclusive)
5389            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5390            * @return the ordered range of matching journal articles that the user has permission to view
5391            * @throws SystemException if a system exception occurred
5392            */
5393            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5394                    long groupId, long folderId, int[] statuses, int start, int end,
5395                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5396                    throws com.liferay.portal.kernel.exception.SystemException {
5397                    return getPersistence()
5398                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
5399                            orderByComparator);
5400            }
5401    
5402            /**
5403            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5404            *
5405            * <p>
5406            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5407            * </p>
5408            *
5409            * @param groupId the group ID
5410            * @param folderId the folder ID
5411            * @param statuses the statuses
5412            * @return the matching journal articles
5413            * @throws SystemException if a system exception occurred
5414            */
5415            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5416                    long groupId, long folderId, int[] statuses)
5417                    throws com.liferay.portal.kernel.exception.SystemException {
5418                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
5419            }
5420    
5421            /**
5422            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5423            *
5424            * <p>
5425            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5426            * </p>
5427            *
5428            * @param groupId the group ID
5429            * @param folderId the folder ID
5430            * @param statuses the statuses
5431            * @param start the lower bound of the range of journal articles
5432            * @param end the upper bound of the range of journal articles (not inclusive)
5433            * @return the range of matching journal articles
5434            * @throws SystemException if a system exception occurred
5435            */
5436            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5437                    long groupId, long folderId, int[] statuses, int start, int end)
5438                    throws com.liferay.portal.kernel.exception.SystemException {
5439                    return getPersistence()
5440                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
5441            }
5442    
5443            /**
5444            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5445            *
5446            * <p>
5447            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5448            * </p>
5449            *
5450            * @param groupId the group ID
5451            * @param folderId the folder ID
5452            * @param statuses the statuses
5453            * @param start the lower bound of the range of journal articles
5454            * @param end the upper bound of the range of journal articles (not inclusive)
5455            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5456            * @return the ordered range of matching journal articles
5457            * @throws SystemException if a system exception occurred
5458            */
5459            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5460                    long groupId, long folderId, int[] statuses, int start, int end,
5461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5462                    throws com.liferay.portal.kernel.exception.SystemException {
5463                    return getPersistence()
5464                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
5465                            orderByComparator);
5466            }
5467    
5468            /**
5469            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
5470            *
5471            * @param groupId the group ID
5472            * @param folderId the folder ID
5473            * @param status the status
5474            * @throws SystemException if a system exception occurred
5475            */
5476            public static void removeByG_F_ST(long groupId, long folderId, int status)
5477                    throws com.liferay.portal.kernel.exception.SystemException {
5478                    getPersistence().removeByG_F_ST(groupId, folderId, status);
5479            }
5480    
5481            /**
5482            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5483            *
5484            * @param groupId the group ID
5485            * @param folderId the folder ID
5486            * @param status the status
5487            * @return the number of matching journal articles
5488            * @throws SystemException if a system exception occurred
5489            */
5490            public static int countByG_F_ST(long groupId, long folderId, int status)
5491                    throws com.liferay.portal.kernel.exception.SystemException {
5492                    return getPersistence().countByG_F_ST(groupId, folderId, status);
5493            }
5494    
5495            /**
5496            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5497            *
5498            * @param groupId the group ID
5499            * @param folderId the folder ID
5500            * @param statuses the statuses
5501            * @return the number of matching journal articles
5502            * @throws SystemException if a system exception occurred
5503            */
5504            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
5505                    throws com.liferay.portal.kernel.exception.SystemException {
5506                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
5507            }
5508    
5509            /**
5510            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5511            *
5512            * @param groupId the group ID
5513            * @param folderId the folder ID
5514            * @param status the status
5515            * @return the number of matching journal articles that the user has permission to view
5516            * @throws SystemException if a system exception occurred
5517            */
5518            public static int filterCountByG_F_ST(long groupId, long folderId,
5519                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5520                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
5521            }
5522    
5523            /**
5524            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5525            *
5526            * @param groupId the group ID
5527            * @param folderId the folder ID
5528            * @param statuses the statuses
5529            * @return the number of matching journal articles that the user has permission to view
5530            * @throws SystemException if a system exception occurred
5531            */
5532            public static int filterCountByG_F_ST(long groupId, long folderId,
5533                    int[] statuses)
5534                    throws com.liferay.portal.kernel.exception.SystemException {
5535                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
5536            }
5537    
5538            /**
5539            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5540            *
5541            * @param groupId the group ID
5542            * @param classNameId the class name ID
5543            * @param classPK the class p k
5544            * @return the matching journal articles
5545            * @throws SystemException if a system exception occurred
5546            */
5547            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5548                    long groupId, long classNameId, long classPK)
5549                    throws com.liferay.portal.kernel.exception.SystemException {
5550                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5551            }
5552    
5553            /**
5554            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5555            *
5556            * <p>
5557            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5558            * </p>
5559            *
5560            * @param groupId the group ID
5561            * @param classNameId the class name ID
5562            * @param classPK the class p k
5563            * @param start the lower bound of the range of journal articles
5564            * @param end the upper bound of the range of journal articles (not inclusive)
5565            * @return the range of matching journal articles
5566            * @throws SystemException if a system exception occurred
5567            */
5568            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5569                    long groupId, long classNameId, long classPK, int start, int end)
5570                    throws com.liferay.portal.kernel.exception.SystemException {
5571                    return getPersistence()
5572                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5573            }
5574    
5575            /**
5576            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5577            *
5578            * <p>
5579            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5580            * </p>
5581            *
5582            * @param groupId the group ID
5583            * @param classNameId the class name ID
5584            * @param classPK the class p k
5585            * @param start the lower bound of the range of journal articles
5586            * @param end the upper bound of the range of journal articles (not inclusive)
5587            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5588            * @return the ordered range of matching journal articles
5589            * @throws SystemException if a system exception occurred
5590            */
5591            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5592                    long groupId, long classNameId, long classPK, int start, int end,
5593                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5594                    throws com.liferay.portal.kernel.exception.SystemException {
5595                    return getPersistence()
5596                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
5597                            orderByComparator);
5598            }
5599    
5600            /**
5601            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5602            *
5603            * @param groupId the group ID
5604            * @param classNameId the class name ID
5605            * @param classPK the class p k
5606            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5607            * @return the first matching journal article
5608            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5609            * @throws SystemException if a system exception occurred
5610            */
5611            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
5612                    long groupId, long classNameId, long classPK,
5613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5614                    throws com.liferay.portal.kernel.exception.SystemException,
5615                            com.liferay.portlet.journal.NoSuchArticleException {
5616                    return getPersistence()
5617                                       .findByG_C_C_First(groupId, classNameId, classPK,
5618                            orderByComparator);
5619            }
5620    
5621            /**
5622            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5623            *
5624            * @param groupId the group ID
5625            * @param classNameId the class name ID
5626            * @param classPK the class p k
5627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5628            * @return the first matching journal article, or <code>null</code> 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 fetchByG_C_C_First(
5632                    long groupId, long classNameId, long classPK,
5633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5634                    throws com.liferay.portal.kernel.exception.SystemException {
5635                    return getPersistence()
5636                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5637                            orderByComparator);
5638            }
5639    
5640            /**
5641            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5642            *
5643            * @param groupId the group ID
5644            * @param classNameId the class name ID
5645            * @param classPK the class p k
5646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5647            * @return the last matching journal article
5648            * @throws com.liferay.portlet.journal.NoSuchArticleException 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 findByG_C_C_Last(
5652                    long groupId, long classNameId, long classPK,
5653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5654                    throws com.liferay.portal.kernel.exception.SystemException,
5655                            com.liferay.portlet.journal.NoSuchArticleException {
5656                    return getPersistence()
5657                                       .findByG_C_C_Last(groupId, classNameId, classPK,
5658                            orderByComparator);
5659            }
5660    
5661            /**
5662            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5663            *
5664            * @param groupId the group ID
5665            * @param classNameId the class name ID
5666            * @param classPK the class p k
5667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5668            * @return the last matching journal article, or <code>null</code> 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 fetchByG_C_C_Last(
5672                    long groupId, long classNameId, long classPK,
5673                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5674                    throws com.liferay.portal.kernel.exception.SystemException {
5675                    return getPersistence()
5676                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
5677                            orderByComparator);
5678            }
5679    
5680            /**
5681            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5682            *
5683            * @param id the primary key of the current journal article
5684            * @param groupId the group ID
5685            * @param classNameId the class name ID
5686            * @param classPK the class p k
5687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5688            * @return the previous, current, and next journal article
5689            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5690            * @throws SystemException if a system exception occurred
5691            */
5692            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
5693                    long id, long groupId, long classNameId, long classPK,
5694                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5695                    throws com.liferay.portal.kernel.exception.SystemException,
5696                            com.liferay.portlet.journal.NoSuchArticleException {
5697                    return getPersistence()
5698                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5699                            orderByComparator);
5700            }
5701    
5702            /**
5703            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5704            *
5705            * @param groupId the group ID
5706            * @param classNameId the class name ID
5707            * @param classPK the class p k
5708            * @return the matching journal articles that the user has permission to view
5709            * @throws SystemException if a system exception occurred
5710            */
5711            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5712                    long groupId, long classNameId, long classPK)
5713                    throws com.liferay.portal.kernel.exception.SystemException {
5714                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5715            }
5716    
5717            /**
5718            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5719            *
5720            * <p>
5721            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5722            * </p>
5723            *
5724            * @param groupId the group ID
5725            * @param classNameId the class name ID
5726            * @param classPK the class p k
5727            * @param start the lower bound of the range of journal articles
5728            * @param end the upper bound of the range of journal articles (not inclusive)
5729            * @return the range of matching journal articles that the user has permission to view
5730            * @throws SystemException if a system exception occurred
5731            */
5732            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5733                    long groupId, long classNameId, long classPK, int start, int end)
5734                    throws com.liferay.portal.kernel.exception.SystemException {
5735                    return getPersistence()
5736                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
5737            }
5738    
5739            /**
5740            * 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;.
5741            *
5742            * <p>
5743            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5744            * </p>
5745            *
5746            * @param groupId the group ID
5747            * @param classNameId the class name ID
5748            * @param classPK the class p k
5749            * @param start the lower bound of the range of journal articles
5750            * @param end the upper bound of the range of journal articles (not inclusive)
5751            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5752            * @return the ordered range of matching journal articles that the user has permission to view
5753            * @throws SystemException if a system exception occurred
5754            */
5755            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5756                    long groupId, long classNameId, long classPK, int start, int end,
5757                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5758                    throws com.liferay.portal.kernel.exception.SystemException {
5759                    return getPersistence()
5760                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
5761                            end, orderByComparator);
5762            }
5763    
5764            /**
5765            * 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;.
5766            *
5767            * @param id the primary key of the current journal article
5768            * @param groupId the group ID
5769            * @param classNameId the class name ID
5770            * @param classPK the class p k
5771            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5772            * @return the previous, current, and next journal article
5773            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5774            * @throws SystemException if a system exception occurred
5775            */
5776            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
5777                    long id, long groupId, long classNameId, long classPK,
5778                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5779                    throws com.liferay.portal.kernel.exception.SystemException,
5780                            com.liferay.portlet.journal.NoSuchArticleException {
5781                    return getPersistence()
5782                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
5783                            classPK, orderByComparator);
5784            }
5785    
5786            /**
5787            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5788            *
5789            * @param groupId the group ID
5790            * @param classNameId the class name ID
5791            * @param classPK the class p k
5792            * @throws SystemException if a system exception occurred
5793            */
5794            public static void removeByG_C_C(long groupId, long classNameId,
5795                    long classPK)
5796                    throws com.liferay.portal.kernel.exception.SystemException {
5797                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5798            }
5799    
5800            /**
5801            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5802            *
5803            * @param groupId the group ID
5804            * @param classNameId the class name ID
5805            * @param classPK the class p k
5806            * @return the number of matching journal articles
5807            * @throws SystemException if a system exception occurred
5808            */
5809            public static int countByG_C_C(long groupId, long classNameId, long classPK)
5810                    throws com.liferay.portal.kernel.exception.SystemException {
5811                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5812            }
5813    
5814            /**
5815            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5816            *
5817            * @param groupId the group ID
5818            * @param classNameId the class name ID
5819            * @param classPK the class p k
5820            * @return the number of matching journal articles that the user has permission to view
5821            * @throws SystemException if a system exception occurred
5822            */
5823            public static int filterCountByG_C_C(long groupId, long classNameId,
5824                    long classPK)
5825                    throws com.liferay.portal.kernel.exception.SystemException {
5826                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5827            }
5828    
5829            /**
5830            * 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.
5831            *
5832            * @param groupId the group ID
5833            * @param classNameId the class name ID
5834            * @param structureId the structure ID
5835            * @return the matching journal article
5836            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5837            * @throws SystemException if a system exception occurred
5838            */
5839            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
5840                    long groupId, long classNameId, java.lang.String structureId)
5841                    throws com.liferay.portal.kernel.exception.SystemException,
5842                            com.liferay.portlet.journal.NoSuchArticleException {
5843                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
5844            }
5845    
5846            /**
5847            * 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.
5848            *
5849            * @param groupId the group ID
5850            * @param classNameId the class name ID
5851            * @param structureId the structure ID
5852            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5853            * @throws SystemException if a system exception occurred
5854            */
5855            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5856                    long groupId, long classNameId, java.lang.String structureId)
5857                    throws com.liferay.portal.kernel.exception.SystemException {
5858                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
5859            }
5860    
5861            /**
5862            * 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.
5863            *
5864            * @param groupId the group ID
5865            * @param classNameId the class name ID
5866            * @param structureId the structure ID
5867            * @param retrieveFromCache whether to use the finder cache
5868            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5869            * @throws SystemException if a system exception occurred
5870            */
5871            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5872                    long groupId, long classNameId, java.lang.String structureId,
5873                    boolean retrieveFromCache)
5874                    throws com.liferay.portal.kernel.exception.SystemException {
5875                    return getPersistence()
5876                                       .fetchByG_C_S(groupId, classNameId, structureId,
5877                            retrieveFromCache);
5878            }
5879    
5880            /**
5881            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
5882            *
5883            * @param groupId the group ID
5884            * @param classNameId the class name ID
5885            * @param structureId the structure ID
5886            * @return the journal article that was removed
5887            * @throws SystemException if a system exception occurred
5888            */
5889            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
5890                    long groupId, long classNameId, java.lang.String structureId)
5891                    throws com.liferay.portal.kernel.exception.SystemException,
5892                            com.liferay.portlet.journal.NoSuchArticleException {
5893                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
5894            }
5895    
5896            /**
5897            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
5898            *
5899            * @param groupId the group ID
5900            * @param classNameId the class name ID
5901            * @param structureId the structure ID
5902            * @return the number of matching journal articles
5903            * @throws SystemException if a system exception occurred
5904            */
5905            public static int countByG_C_S(long groupId, long classNameId,
5906                    java.lang.String structureId)
5907                    throws com.liferay.portal.kernel.exception.SystemException {
5908                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
5909            }
5910    
5911            /**
5912            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5913            *
5914            * @param groupId the group ID
5915            * @param classNameId the class name ID
5916            * @param templateId the template ID
5917            * @return the matching journal articles
5918            * @throws SystemException if a system exception occurred
5919            */
5920            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5921                    long groupId, long classNameId, java.lang.String templateId)
5922                    throws com.liferay.portal.kernel.exception.SystemException {
5923                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
5924            }
5925    
5926            /**
5927            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5928            *
5929            * <p>
5930            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5931            * </p>
5932            *
5933            * @param groupId the group ID
5934            * @param classNameId the class name ID
5935            * @param templateId the template ID
5936            * @param start the lower bound of the range of journal articles
5937            * @param end the upper bound of the range of journal articles (not inclusive)
5938            * @return the range of matching journal articles
5939            * @throws SystemException if a system exception occurred
5940            */
5941            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5942                    long groupId, long classNameId, java.lang.String templateId, int start,
5943                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5944                    return getPersistence()
5945                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
5946            }
5947    
5948            /**
5949            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5950            *
5951            * <p>
5952            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5953            * </p>
5954            *
5955            * @param groupId the group ID
5956            * @param classNameId the class name ID
5957            * @param templateId the template ID
5958            * @param start the lower bound of the range of journal articles
5959            * @param end the upper bound of the range of journal articles (not inclusive)
5960            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5961            * @return the ordered range of matching journal articles
5962            * @throws SystemException if a system exception occurred
5963            */
5964            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5965                    long groupId, long classNameId, java.lang.String templateId, int start,
5966                    int end,
5967                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5968                    throws com.liferay.portal.kernel.exception.SystemException {
5969                    return getPersistence()
5970                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
5971                            orderByComparator);
5972            }
5973    
5974            /**
5975            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5976            *
5977            * @param groupId the group ID
5978            * @param classNameId the class name ID
5979            * @param templateId the template ID
5980            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5981            * @return the first matching journal article
5982            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5983            * @throws SystemException if a system exception occurred
5984            */
5985            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
5986                    long groupId, long classNameId, java.lang.String templateId,
5987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5988                    throws com.liferay.portal.kernel.exception.SystemException,
5989                            com.liferay.portlet.journal.NoSuchArticleException {
5990                    return getPersistence()
5991                                       .findByG_C_T_First(groupId, classNameId, templateId,
5992                            orderByComparator);
5993            }
5994    
5995            /**
5996            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5997            *
5998            * @param groupId the group ID
5999            * @param classNameId the class name ID
6000            * @param templateId the template ID
6001            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6002            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6003            * @throws SystemException if a system exception occurred
6004            */
6005            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
6006                    long groupId, long classNameId, java.lang.String templateId,
6007                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6008                    throws com.liferay.portal.kernel.exception.SystemException {
6009                    return getPersistence()
6010                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
6011                            orderByComparator);
6012            }
6013    
6014            /**
6015            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6016            *
6017            * @param groupId the group ID
6018            * @param classNameId the class name ID
6019            * @param templateId the template ID
6020            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6021            * @return the last matching journal article
6022            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6023            * @throws SystemException if a system exception occurred
6024            */
6025            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
6026                    long groupId, long classNameId, java.lang.String templateId,
6027                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6028                    throws com.liferay.portal.kernel.exception.SystemException,
6029                            com.liferay.portlet.journal.NoSuchArticleException {
6030                    return getPersistence()
6031                                       .findByG_C_T_Last(groupId, classNameId, templateId,
6032                            orderByComparator);
6033            }
6034    
6035            /**
6036            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6037            *
6038            * @param groupId the group ID
6039            * @param classNameId the class name ID
6040            * @param templateId the template ID
6041            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6042            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6043            * @throws SystemException if a system exception occurred
6044            */
6045            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
6046                    long groupId, long classNameId, java.lang.String templateId,
6047                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6048                    throws com.liferay.portal.kernel.exception.SystemException {
6049                    return getPersistence()
6050                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
6051                            orderByComparator);
6052            }
6053    
6054            /**
6055            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6056            *
6057            * @param id the primary key of the current journal article
6058            * @param groupId the group ID
6059            * @param classNameId the class name ID
6060            * @param templateId the template ID
6061            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6062            * @return the previous, current, and next journal article
6063            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6064            * @throws SystemException if a system exception occurred
6065            */
6066            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
6067                    long id, long groupId, long classNameId, java.lang.String templateId,
6068                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6069                    throws com.liferay.portal.kernel.exception.SystemException,
6070                            com.liferay.portlet.journal.NoSuchArticleException {
6071                    return getPersistence()
6072                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
6073                            templateId, orderByComparator);
6074            }
6075    
6076            /**
6077            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6078            *
6079            * @param groupId the group ID
6080            * @param classNameId the class name ID
6081            * @param templateId the template ID
6082            * @return the matching journal articles that the user has permission to view
6083            * @throws SystemException if a system exception occurred
6084            */
6085            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6086                    long groupId, long classNameId, java.lang.String templateId)
6087                    throws com.liferay.portal.kernel.exception.SystemException {
6088                    return getPersistence()
6089                                       .filterFindByG_C_T(groupId, classNameId, templateId);
6090            }
6091    
6092            /**
6093            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6094            *
6095            * <p>
6096            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6097            * </p>
6098            *
6099            * @param groupId the group ID
6100            * @param classNameId the class name ID
6101            * @param templateId the template ID
6102            * @param start the lower bound of the range of journal articles
6103            * @param end the upper bound of the range of journal articles (not inclusive)
6104            * @return the range of matching journal articles that the user has permission to view
6105            * @throws SystemException if a system exception occurred
6106            */
6107            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6108                    long groupId, long classNameId, java.lang.String templateId, int start,
6109                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6110                    return getPersistence()
6111                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6112                            end);
6113            }
6114    
6115            /**
6116            * 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;.
6117            *
6118            * <p>
6119            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6120            * </p>
6121            *
6122            * @param groupId the group ID
6123            * @param classNameId the class name ID
6124            * @param templateId the template ID
6125            * @param start the lower bound of the range of journal articles
6126            * @param end the upper bound of the range of journal articles (not inclusive)
6127            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6128            * @return the ordered range of matching journal articles that the user has permission to view
6129            * @throws SystemException if a system exception occurred
6130            */
6131            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6132                    long groupId, long classNameId, java.lang.String templateId, int start,
6133                    int end,
6134                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6135                    throws com.liferay.portal.kernel.exception.SystemException {
6136                    return getPersistence()
6137                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6138                            end, orderByComparator);
6139            }
6140    
6141            /**
6142            * 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;.
6143            *
6144            * @param id the primary key of the current journal article
6145            * @param groupId the group ID
6146            * @param classNameId the class name ID
6147            * @param templateId the template ID
6148            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6149            * @return the previous, current, and next journal article
6150            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6151            * @throws SystemException if a system exception occurred
6152            */
6153            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
6154                    long id, long groupId, long classNameId, java.lang.String templateId,
6155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6156                    throws com.liferay.portal.kernel.exception.SystemException,
6157                            com.liferay.portlet.journal.NoSuchArticleException {
6158                    return getPersistence()
6159                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
6160                            templateId, orderByComparator);
6161            }
6162    
6163            /**
6164            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
6165            *
6166            * @param groupId the group ID
6167            * @param classNameId the class name ID
6168            * @param templateId the template ID
6169            * @throws SystemException if a system exception occurred
6170            */
6171            public static void removeByG_C_T(long groupId, long classNameId,
6172                    java.lang.String templateId)
6173                    throws com.liferay.portal.kernel.exception.SystemException {
6174                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
6175            }
6176    
6177            /**
6178            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6179            *
6180            * @param groupId the group ID
6181            * @param classNameId the class name ID
6182            * @param templateId the template ID
6183            * @return the number of matching journal articles
6184            * @throws SystemException if a system exception occurred
6185            */
6186            public static int countByG_C_T(long groupId, long classNameId,
6187                    java.lang.String templateId)
6188                    throws com.liferay.portal.kernel.exception.SystemException {
6189                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
6190            }
6191    
6192            /**
6193            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6194            *
6195            * @param groupId the group ID
6196            * @param classNameId the class name ID
6197            * @param templateId the template ID
6198            * @return the number of matching journal articles that the user has permission to view
6199            * @throws SystemException if a system exception occurred
6200            */
6201            public static int filterCountByG_C_T(long groupId, long classNameId,
6202                    java.lang.String templateId)
6203                    throws com.liferay.portal.kernel.exception.SystemException {
6204                    return getPersistence()
6205                                       .filterCountByG_C_T(groupId, classNameId, templateId);
6206            }
6207    
6208            /**
6209            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6210            *
6211            * @param groupId the group ID
6212            * @param classNameId the class name ID
6213            * @param layoutUuid the layout uuid
6214            * @return the matching journal articles
6215            * @throws SystemException if a system exception occurred
6216            */
6217            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6218                    long groupId, long classNameId, java.lang.String layoutUuid)
6219                    throws com.liferay.portal.kernel.exception.SystemException {
6220                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
6221            }
6222    
6223            /**
6224            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6225            *
6226            * <p>
6227            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6228            * </p>
6229            *
6230            * @param groupId the group ID
6231            * @param classNameId the class name ID
6232            * @param layoutUuid the layout uuid
6233            * @param start the lower bound of the range of journal articles
6234            * @param end the upper bound of the range of journal articles (not inclusive)
6235            * @return the range of matching journal articles
6236            * @throws SystemException if a system exception occurred
6237            */
6238            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6239                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6240                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6241                    return getPersistence()
6242                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6243            }
6244    
6245            /**
6246            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6247            *
6248            * <p>
6249            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6250            * </p>
6251            *
6252            * @param groupId the group ID
6253            * @param classNameId the class name ID
6254            * @param layoutUuid the layout uuid
6255            * @param start the lower bound of the range of journal articles
6256            * @param end the upper bound of the range of journal articles (not inclusive)
6257            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6258            * @return the ordered range of matching journal articles
6259            * @throws SystemException if a system exception occurred
6260            */
6261            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6262                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6263                    int end,
6264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6265                    throws com.liferay.portal.kernel.exception.SystemException {
6266                    return getPersistence()
6267                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6268                            orderByComparator);
6269            }
6270    
6271            /**
6272            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6273            *
6274            * @param groupId the group ID
6275            * @param classNameId the class name ID
6276            * @param layoutUuid the layout uuid
6277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6278            * @return the first matching journal article
6279            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6280            * @throws SystemException if a system exception occurred
6281            */
6282            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
6283                    long groupId, long classNameId, java.lang.String layoutUuid,
6284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6285                    throws com.liferay.portal.kernel.exception.SystemException,
6286                            com.liferay.portlet.journal.NoSuchArticleException {
6287                    return getPersistence()
6288                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
6289                            orderByComparator);
6290            }
6291    
6292            /**
6293            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6294            *
6295            * @param groupId the group ID
6296            * @param classNameId the class name ID
6297            * @param layoutUuid the layout uuid
6298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6299            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6300            * @throws SystemException if a system exception occurred
6301            */
6302            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
6303                    long groupId, long classNameId, java.lang.String layoutUuid,
6304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6305                    throws com.liferay.portal.kernel.exception.SystemException {
6306                    return getPersistence()
6307                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
6308                            orderByComparator);
6309            }
6310    
6311            /**
6312            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6313            *
6314            * @param groupId the group ID
6315            * @param classNameId the class name ID
6316            * @param layoutUuid the layout uuid
6317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6318            * @return the last matching journal article
6319            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6320            * @throws SystemException if a system exception occurred
6321            */
6322            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
6323                    long groupId, long classNameId, java.lang.String layoutUuid,
6324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6325                    throws com.liferay.portal.kernel.exception.SystemException,
6326                            com.liferay.portlet.journal.NoSuchArticleException {
6327                    return getPersistence()
6328                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
6329                            orderByComparator);
6330            }
6331    
6332            /**
6333            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6334            *
6335            * @param groupId the group ID
6336            * @param classNameId the class name ID
6337            * @param layoutUuid the layout uuid
6338            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6339            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6340            * @throws SystemException if a system exception occurred
6341            */
6342            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
6343                    long groupId, long classNameId, java.lang.String layoutUuid,
6344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6345                    throws com.liferay.portal.kernel.exception.SystemException {
6346                    return getPersistence()
6347                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
6348                            orderByComparator);
6349            }
6350    
6351            /**
6352            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6353            *
6354            * @param id the primary key of the current journal article
6355            * @param groupId the group ID
6356            * @param classNameId the class name ID
6357            * @param layoutUuid the layout uuid
6358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6359            * @return the previous, current, and next journal article
6360            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6361            * @throws SystemException if a system exception occurred
6362            */
6363            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
6364                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6366                    throws com.liferay.portal.kernel.exception.SystemException,
6367                            com.liferay.portlet.journal.NoSuchArticleException {
6368                    return getPersistence()
6369                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
6370                            layoutUuid, orderByComparator);
6371            }
6372    
6373            /**
6374            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6375            *
6376            * @param groupId the group ID
6377            * @param classNameId the class name ID
6378            * @param layoutUuid the layout uuid
6379            * @return the matching journal articles that the user has permission to view
6380            * @throws SystemException if a system exception occurred
6381            */
6382            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6383                    long groupId, long classNameId, java.lang.String layoutUuid)
6384                    throws com.liferay.portal.kernel.exception.SystemException {
6385                    return getPersistence()
6386                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
6387            }
6388    
6389            /**
6390            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6391            *
6392            * <p>
6393            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6394            * </p>
6395            *
6396            * @param groupId the group ID
6397            * @param classNameId the class name ID
6398            * @param layoutUuid the layout uuid
6399            * @param start the lower bound of the range of journal articles
6400            * @param end the upper bound of the range of journal articles (not inclusive)
6401            * @return the range of matching journal articles that the user has permission to view
6402            * @throws SystemException if a system exception occurred
6403            */
6404            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6405                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6406                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6407                    return getPersistence()
6408                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6409                            end);
6410            }
6411    
6412            /**
6413            * 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;.
6414            *
6415            * <p>
6416            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6417            * </p>
6418            *
6419            * @param groupId the group ID
6420            * @param classNameId the class name ID
6421            * @param layoutUuid the layout uuid
6422            * @param start the lower bound of the range of journal articles
6423            * @param end the upper bound of the range of journal articles (not inclusive)
6424            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6425            * @return the ordered range of matching journal articles that the user has permission to view
6426            * @throws SystemException if a system exception occurred
6427            */
6428            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6429                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6430                    int end,
6431                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6432                    throws com.liferay.portal.kernel.exception.SystemException {
6433                    return getPersistence()
6434                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6435                            end, orderByComparator);
6436            }
6437    
6438            /**
6439            * 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;.
6440            *
6441            * @param id the primary key of the current journal article
6442            * @param groupId the group ID
6443            * @param classNameId the class name ID
6444            * @param layoutUuid the layout uuid
6445            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6446            * @return the previous, current, and next journal article
6447            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6448            * @throws SystemException if a system exception occurred
6449            */
6450            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
6451                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6452                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6453                    throws com.liferay.portal.kernel.exception.SystemException,
6454                            com.liferay.portlet.journal.NoSuchArticleException {
6455                    return getPersistence()
6456                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6457                            layoutUuid, orderByComparator);
6458            }
6459    
6460            /**
6461            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6462            *
6463            * @param groupId the group ID
6464            * @param classNameId the class name ID
6465            * @param layoutUuid the layout uuid
6466            * @throws SystemException if a system exception occurred
6467            */
6468            public static void removeByG_C_L(long groupId, long classNameId,
6469                    java.lang.String layoutUuid)
6470                    throws com.liferay.portal.kernel.exception.SystemException {
6471                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6472            }
6473    
6474            /**
6475            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6476            *
6477            * @param groupId the group ID
6478            * @param classNameId the class name ID
6479            * @param layoutUuid the layout uuid
6480            * @return the number of matching journal articles
6481            * @throws SystemException if a system exception occurred
6482            */
6483            public static int countByG_C_L(long groupId, long classNameId,
6484                    java.lang.String layoutUuid)
6485                    throws com.liferay.portal.kernel.exception.SystemException {
6486                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6487            }
6488    
6489            /**
6490            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6491            *
6492            * @param groupId the group ID
6493            * @param classNameId the class name ID
6494            * @param layoutUuid the layout uuid
6495            * @return the number of matching journal articles that the user has permission to view
6496            * @throws SystemException if a system exception occurred
6497            */
6498            public static int filterCountByG_C_L(long groupId, long classNameId,
6499                    java.lang.String layoutUuid)
6500                    throws com.liferay.portal.kernel.exception.SystemException {
6501                    return getPersistence()
6502                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
6503            }
6504    
6505            /**
6506            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6507            *
6508            * @param groupId the group ID
6509            * @param userId the user ID
6510            * @param classNameId the class name ID
6511            * @return the matching journal articles
6512            * @throws SystemException if a system exception occurred
6513            */
6514            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6515                    long groupId, long userId, long classNameId)
6516                    throws com.liferay.portal.kernel.exception.SystemException {
6517                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
6518            }
6519    
6520            /**
6521            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6522            *
6523            * <p>
6524            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6525            * </p>
6526            *
6527            * @param groupId the group ID
6528            * @param userId the user ID
6529            * @param classNameId the class name ID
6530            * @param start the lower bound of the range of journal articles
6531            * @param end the upper bound of the range of journal articles (not inclusive)
6532            * @return the range of matching journal articles
6533            * @throws SystemException if a system exception occurred
6534            */
6535            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6536                    long groupId, long userId, long classNameId, int start, int end)
6537                    throws com.liferay.portal.kernel.exception.SystemException {
6538                    return getPersistence()
6539                                       .findByG_U_C(groupId, userId, classNameId, start, end);
6540            }
6541    
6542            /**
6543            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6544            *
6545            * <p>
6546            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6547            * </p>
6548            *
6549            * @param groupId the group ID
6550            * @param userId the user ID
6551            * @param classNameId the class name ID
6552            * @param start the lower bound of the range of journal articles
6553            * @param end the upper bound of the range of journal articles (not inclusive)
6554            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6555            * @return the ordered range of matching journal articles
6556            * @throws SystemException if a system exception occurred
6557            */
6558            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6559                    long groupId, long userId, long classNameId, int start, int end,
6560                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6561                    throws com.liferay.portal.kernel.exception.SystemException {
6562                    return getPersistence()
6563                                       .findByG_U_C(groupId, userId, classNameId, start, end,
6564                            orderByComparator);
6565            }
6566    
6567            /**
6568            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6569            *
6570            * @param groupId the group ID
6571            * @param userId the user ID
6572            * @param classNameId the class name ID
6573            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6574            * @return the first matching journal article
6575            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6576            * @throws SystemException if a system exception occurred
6577            */
6578            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
6579                    long groupId, long userId, long classNameId,
6580                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6581                    throws com.liferay.portal.kernel.exception.SystemException,
6582                            com.liferay.portlet.journal.NoSuchArticleException {
6583                    return getPersistence()
6584                                       .findByG_U_C_First(groupId, userId, classNameId,
6585                            orderByComparator);
6586            }
6587    
6588            /**
6589            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6590            *
6591            * @param groupId the group ID
6592            * @param userId the user ID
6593            * @param classNameId the class name ID
6594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6595            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6596            * @throws SystemException if a system exception occurred
6597            */
6598            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
6599                    long groupId, long userId, long classNameId,
6600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6601                    throws com.liferay.portal.kernel.exception.SystemException {
6602                    return getPersistence()
6603                                       .fetchByG_U_C_First(groupId, userId, classNameId,
6604                            orderByComparator);
6605            }
6606    
6607            /**
6608            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6609            *
6610            * @param groupId the group ID
6611            * @param userId the user ID
6612            * @param classNameId the class name ID
6613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6614            * @return the last matching journal article
6615            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6616            * @throws SystemException if a system exception occurred
6617            */
6618            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
6619                    long groupId, long userId, long classNameId,
6620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6621                    throws com.liferay.portal.kernel.exception.SystemException,
6622                            com.liferay.portlet.journal.NoSuchArticleException {
6623                    return getPersistence()
6624                                       .findByG_U_C_Last(groupId, userId, classNameId,
6625                            orderByComparator);
6626            }
6627    
6628            /**
6629            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6630            *
6631            * @param groupId the group ID
6632            * @param userId the user ID
6633            * @param classNameId the class name ID
6634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6635            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6636            * @throws SystemException if a system exception occurred
6637            */
6638            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
6639                    long groupId, long userId, long classNameId,
6640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6641                    throws com.liferay.portal.kernel.exception.SystemException {
6642                    return getPersistence()
6643                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
6644                            orderByComparator);
6645            }
6646    
6647            /**
6648            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6649            *
6650            * @param id the primary key of the current journal article
6651            * @param groupId the group ID
6652            * @param userId the user ID
6653            * @param classNameId the class name ID
6654            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6655            * @return the previous, current, and next journal article
6656            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6657            * @throws SystemException if a system exception occurred
6658            */
6659            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
6660                    long id, long groupId, long userId, long classNameId,
6661                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6662                    throws com.liferay.portal.kernel.exception.SystemException,
6663                            com.liferay.portlet.journal.NoSuchArticleException {
6664                    return getPersistence()
6665                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
6666                            orderByComparator);
6667            }
6668    
6669            /**
6670            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6671            *
6672            * @param groupId the group ID
6673            * @param userId the user ID
6674            * @param classNameId the class name ID
6675            * @return the matching journal articles that the user has permission to view
6676            * @throws SystemException if a system exception occurred
6677            */
6678            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6679                    long groupId, long userId, long classNameId)
6680                    throws com.liferay.portal.kernel.exception.SystemException {
6681                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
6682            }
6683    
6684            /**
6685            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6686            *
6687            * <p>
6688            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6689            * </p>
6690            *
6691            * @param groupId the group ID
6692            * @param userId the user ID
6693            * @param classNameId the class name ID
6694            * @param start the lower bound of the range of journal articles
6695            * @param end the upper bound of the range of journal articles (not inclusive)
6696            * @return the range of matching journal articles that the user has permission to view
6697            * @throws SystemException if a system exception occurred
6698            */
6699            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6700                    long groupId, long userId, long classNameId, int start, int end)
6701                    throws com.liferay.portal.kernel.exception.SystemException {
6702                    return getPersistence()
6703                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
6704            }
6705    
6706            /**
6707            * 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;.
6708            *
6709            * <p>
6710            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6711            * </p>
6712            *
6713            * @param groupId the group ID
6714            * @param userId the user ID
6715            * @param classNameId the class name ID
6716            * @param start the lower bound of the range of journal articles
6717            * @param end the upper bound of the range of journal articles (not inclusive)
6718            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6719            * @return the ordered range of matching journal articles that the user has permission to view
6720            * @throws SystemException if a system exception occurred
6721            */
6722            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6723                    long groupId, long userId, long classNameId, int start, int end,
6724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6725                    throws com.liferay.portal.kernel.exception.SystemException {
6726                    return getPersistence()
6727                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
6728                            orderByComparator);
6729            }
6730    
6731            /**
6732            * 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;.
6733            *
6734            * @param id the primary key of the current journal article
6735            * @param groupId the group ID
6736            * @param userId the user ID
6737            * @param classNameId the class name ID
6738            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6739            * @return the previous, current, and next journal article
6740            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6741            * @throws SystemException if a system exception occurred
6742            */
6743            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
6744                    long id, long groupId, long userId, long classNameId,
6745                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6746                    throws com.liferay.portal.kernel.exception.SystemException,
6747                            com.liferay.portlet.journal.NoSuchArticleException {
6748                    return getPersistence()
6749                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
6750                            classNameId, orderByComparator);
6751            }
6752    
6753            /**
6754            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
6755            *
6756            * @param groupId the group ID
6757            * @param userId the user ID
6758            * @param classNameId the class name ID
6759            * @throws SystemException if a system exception occurred
6760            */
6761            public static void removeByG_U_C(long groupId, long userId, long classNameId)
6762                    throws com.liferay.portal.kernel.exception.SystemException {
6763                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
6764            }
6765    
6766            /**
6767            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6768            *
6769            * @param groupId the group ID
6770            * @param userId the user ID
6771            * @param classNameId the class name ID
6772            * @return the number of matching journal articles
6773            * @throws SystemException if a system exception occurred
6774            */
6775            public static int countByG_U_C(long groupId, long userId, long classNameId)
6776                    throws com.liferay.portal.kernel.exception.SystemException {
6777                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
6778            }
6779    
6780            /**
6781            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6782            *
6783            * @param groupId the group ID
6784            * @param userId the user ID
6785            * @param classNameId the class name ID
6786            * @return the number of matching journal articles that the user has permission to view
6787            * @throws SystemException if a system exception occurred
6788            */
6789            public static int filterCountByG_U_C(long groupId, long userId,
6790                    long classNameId)
6791                    throws com.liferay.portal.kernel.exception.SystemException {
6792                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
6793            }
6794    
6795            /**
6796            * 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.
6797            *
6798            * @param groupId the group ID
6799            * @param articleId the article ID
6800            * @param version the version
6801            * @return the matching journal article
6802            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6803            * @throws SystemException if a system exception occurred
6804            */
6805            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
6806                    long groupId, java.lang.String articleId, double version)
6807                    throws com.liferay.portal.kernel.exception.SystemException,
6808                            com.liferay.portlet.journal.NoSuchArticleException {
6809                    return getPersistence().findByG_A_V(groupId, articleId, version);
6810            }
6811    
6812            /**
6813            * 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.
6814            *
6815            * @param groupId the group ID
6816            * @param articleId the article ID
6817            * @param version the version
6818            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6819            * @throws SystemException if a system exception occurred
6820            */
6821            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6822                    long groupId, java.lang.String articleId, double version)
6823                    throws com.liferay.portal.kernel.exception.SystemException {
6824                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
6825            }
6826    
6827            /**
6828            * 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.
6829            *
6830            * @param groupId the group ID
6831            * @param articleId the article ID
6832            * @param version the version
6833            * @param retrieveFromCache whether to use the finder cache
6834            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6835            * @throws SystemException if a system exception occurred
6836            */
6837            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6838                    long groupId, java.lang.String articleId, double version,
6839                    boolean retrieveFromCache)
6840                    throws com.liferay.portal.kernel.exception.SystemException {
6841                    return getPersistence()
6842                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
6843            }
6844    
6845            /**
6846            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
6847            *
6848            * @param groupId the group ID
6849            * @param articleId the article ID
6850            * @param version the version
6851            * @return the journal article that was removed
6852            * @throws SystemException if a system exception occurred
6853            */
6854            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
6855                    long groupId, java.lang.String articleId, double version)
6856                    throws com.liferay.portal.kernel.exception.SystemException,
6857                            com.liferay.portlet.journal.NoSuchArticleException {
6858                    return getPersistence().removeByG_A_V(groupId, articleId, version);
6859            }
6860    
6861            /**
6862            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
6863            *
6864            * @param groupId the group ID
6865            * @param articleId the article ID
6866            * @param version the version
6867            * @return the number of matching journal articles
6868            * @throws SystemException if a system exception occurred
6869            */
6870            public static int countByG_A_V(long groupId, java.lang.String articleId,
6871                    double version)
6872                    throws com.liferay.portal.kernel.exception.SystemException {
6873                    return getPersistence().countByG_A_V(groupId, articleId, version);
6874            }
6875    
6876            /**
6877            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6878            *
6879            * @param groupId the group ID
6880            * @param articleId the article ID
6881            * @param status the status
6882            * @return the matching journal articles
6883            * @throws SystemException if a system exception occurred
6884            */
6885            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6886                    long groupId, java.lang.String articleId, int status)
6887                    throws com.liferay.portal.kernel.exception.SystemException {
6888                    return getPersistence().findByG_A_ST(groupId, articleId, status);
6889            }
6890    
6891            /**
6892            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6893            *
6894            * <p>
6895            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6896            * </p>
6897            *
6898            * @param groupId the group ID
6899            * @param articleId the article ID
6900            * @param status the status
6901            * @param start the lower bound of the range of journal articles
6902            * @param end the upper bound of the range of journal articles (not inclusive)
6903            * @return the range of matching journal articles
6904            * @throws SystemException if a system exception occurred
6905            */
6906            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6907                    long groupId, java.lang.String articleId, int status, int start, int end)
6908                    throws com.liferay.portal.kernel.exception.SystemException {
6909                    return getPersistence()
6910                                       .findByG_A_ST(groupId, articleId, status, start, end);
6911            }
6912    
6913            /**
6914            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6915            *
6916            * <p>
6917            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6918            * </p>
6919            *
6920            * @param groupId the group ID
6921            * @param articleId the article ID
6922            * @param status the status
6923            * @param start the lower bound of the range of journal articles
6924            * @param end the upper bound of the range of journal articles (not inclusive)
6925            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6926            * @return the ordered range of matching journal articles
6927            * @throws SystemException if a system exception occurred
6928            */
6929            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6930                    long groupId, java.lang.String articleId, int status, int start,
6931                    int end,
6932                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6933                    throws com.liferay.portal.kernel.exception.SystemException {
6934                    return getPersistence()
6935                                       .findByG_A_ST(groupId, articleId, status, start, end,
6936                            orderByComparator);
6937            }
6938    
6939            /**
6940            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6941            *
6942            * @param groupId the group ID
6943            * @param articleId the article ID
6944            * @param status the status
6945            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6946            * @return the first matching journal article
6947            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6948            * @throws SystemException if a system exception occurred
6949            */
6950            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
6951                    long groupId, java.lang.String articleId, int status,
6952                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6953                    throws com.liferay.portal.kernel.exception.SystemException,
6954                            com.liferay.portlet.journal.NoSuchArticleException {
6955                    return getPersistence()
6956                                       .findByG_A_ST_First(groupId, articleId, status,
6957                            orderByComparator);
6958            }
6959    
6960            /**
6961            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6962            *
6963            * @param groupId the group ID
6964            * @param articleId the article ID
6965            * @param status the status
6966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6967            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6968            * @throws SystemException if a system exception occurred
6969            */
6970            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
6971                    long groupId, java.lang.String articleId, int status,
6972                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6973                    throws com.liferay.portal.kernel.exception.SystemException {
6974                    return getPersistence()
6975                                       .fetchByG_A_ST_First(groupId, articleId, status,
6976                            orderByComparator);
6977            }
6978    
6979            /**
6980            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6981            *
6982            * @param groupId the group ID
6983            * @param articleId the article ID
6984            * @param status the status
6985            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6986            * @return the last matching journal article
6987            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6988            * @throws SystemException if a system exception occurred
6989            */
6990            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
6991                    long groupId, java.lang.String articleId, int status,
6992                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6993                    throws com.liferay.portal.kernel.exception.SystemException,
6994                            com.liferay.portlet.journal.NoSuchArticleException {
6995                    return getPersistence()
6996                                       .findByG_A_ST_Last(groupId, articleId, status,
6997                            orderByComparator);
6998            }
6999    
7000            /**
7001            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7002            *
7003            * @param groupId the group ID
7004            * @param articleId the article ID
7005            * @param status the status
7006            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7007            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7008            * @throws SystemException if a system exception occurred
7009            */
7010            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
7011                    long groupId, java.lang.String articleId, int status,
7012                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7013                    throws com.liferay.portal.kernel.exception.SystemException {
7014                    return getPersistence()
7015                                       .fetchByG_A_ST_Last(groupId, articleId, status,
7016                            orderByComparator);
7017            }
7018    
7019            /**
7020            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7021            *
7022            * @param id the primary key of the current journal article
7023            * @param groupId the group ID
7024            * @param articleId the article ID
7025            * @param status the status
7026            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7027            * @return the previous, current, and next journal article
7028            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7029            * @throws SystemException if a system exception occurred
7030            */
7031            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
7032                    long id, long groupId, java.lang.String articleId, int status,
7033                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7034                    throws com.liferay.portal.kernel.exception.SystemException,
7035                            com.liferay.portlet.journal.NoSuchArticleException {
7036                    return getPersistence()
7037                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
7038                            orderByComparator);
7039            }
7040    
7041            /**
7042            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7043            *
7044            * @param groupId the group ID
7045            * @param articleId the article ID
7046            * @param status the status
7047            * @return the matching journal articles that the user has permission to view
7048            * @throws SystemException if a system exception occurred
7049            */
7050            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7051                    long groupId, java.lang.String articleId, int status)
7052                    throws com.liferay.portal.kernel.exception.SystemException {
7053                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
7054            }
7055    
7056            /**
7057            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7058            *
7059            * <p>
7060            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7061            * </p>
7062            *
7063            * @param groupId the group ID
7064            * @param articleId the article ID
7065            * @param status the status
7066            * @param start the lower bound of the range of journal articles
7067            * @param end the upper bound of the range of journal articles (not inclusive)
7068            * @return the range of matching journal articles that the user has permission to view
7069            * @throws SystemException if a system exception occurred
7070            */
7071            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7072                    long groupId, java.lang.String articleId, int status, int start, int end)
7073                    throws com.liferay.portal.kernel.exception.SystemException {
7074                    return getPersistence()
7075                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
7076            }
7077    
7078            /**
7079            * 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;.
7080            *
7081            * <p>
7082            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7083            * </p>
7084            *
7085            * @param groupId the group ID
7086            * @param articleId the article ID
7087            * @param status the status
7088            * @param start the lower bound of the range of journal articles
7089            * @param end the upper bound of the range of journal articles (not inclusive)
7090            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7091            * @return the ordered range of matching journal articles that the user has permission to view
7092            * @throws SystemException if a system exception occurred
7093            */
7094            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7095                    long groupId, java.lang.String articleId, int status, int start,
7096                    int end,
7097                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7098                    throws com.liferay.portal.kernel.exception.SystemException {
7099                    return getPersistence()
7100                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
7101                            orderByComparator);
7102            }
7103    
7104            /**
7105            * 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;.
7106            *
7107            * @param id the primary key of the current journal article
7108            * @param groupId the group ID
7109            * @param articleId the article ID
7110            * @param status the status
7111            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7112            * @return the previous, current, and next journal article
7113            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7114            * @throws SystemException if a system exception occurred
7115            */
7116            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
7117                    long id, long groupId, java.lang.String articleId, int status,
7118                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7119                    throws com.liferay.portal.kernel.exception.SystemException,
7120                            com.liferay.portlet.journal.NoSuchArticleException {
7121                    return getPersistence()
7122                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
7123                            status, orderByComparator);
7124            }
7125    
7126            /**
7127            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7128            *
7129            * @param groupId the group ID
7130            * @param articleId the article ID
7131            * @param statuses the statuses
7132            * @return the matching journal articles that the user has permission to view
7133            * @throws SystemException if a system exception occurred
7134            */
7135            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7136                    long groupId, java.lang.String articleId, int[] statuses)
7137                    throws com.liferay.portal.kernel.exception.SystemException {
7138                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
7139            }
7140    
7141            /**
7142            * 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;.
7143            *
7144            * <p>
7145            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7146            * </p>
7147            *
7148            * @param groupId the group ID
7149            * @param articleId the article ID
7150            * @param statuses the statuses
7151            * @param start the lower bound of the range of journal articles
7152            * @param end the upper bound of the range of journal articles (not inclusive)
7153            * @return the range of matching journal articles that the user has permission to view
7154            * @throws SystemException if a system exception occurred
7155            */
7156            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7157                    long groupId, java.lang.String articleId, int[] statuses, int start,
7158                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7159                    return getPersistence()
7160                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
7161            }
7162    
7163            /**
7164            * 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;.
7165            *
7166            * <p>
7167            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7168            * </p>
7169            *
7170            * @param groupId the group ID
7171            * @param articleId the article ID
7172            * @param statuses the statuses
7173            * @param start the lower bound of the range of journal articles
7174            * @param end the upper bound of the range of journal articles (not inclusive)
7175            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7176            * @return the ordered range of matching journal articles that the user has permission to view
7177            * @throws SystemException if a system exception occurred
7178            */
7179            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7180                    long groupId, java.lang.String articleId, int[] statuses, int start,
7181                    int end,
7182                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7183                    throws com.liferay.portal.kernel.exception.SystemException {
7184                    return getPersistence()
7185                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
7186                            end, orderByComparator);
7187            }
7188    
7189            /**
7190            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7191            *
7192            * <p>
7193            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7194            * </p>
7195            *
7196            * @param groupId the group ID
7197            * @param articleId the article ID
7198            * @param statuses the statuses
7199            * @return the matching journal articles
7200            * @throws SystemException if a system exception occurred
7201            */
7202            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7203                    long groupId, java.lang.String articleId, int[] statuses)
7204                    throws com.liferay.portal.kernel.exception.SystemException {
7205                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
7206            }
7207    
7208            /**
7209            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7210            *
7211            * <p>
7212            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7213            * </p>
7214            *
7215            * @param groupId the group ID
7216            * @param articleId the article ID
7217            * @param statuses the statuses
7218            * @param start the lower bound of the range of journal articles
7219            * @param end the upper bound of the range of journal articles (not inclusive)
7220            * @return the range of matching journal articles
7221            * @throws SystemException if a system exception occurred
7222            */
7223            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7224                    long groupId, java.lang.String articleId, int[] statuses, int start,
7225                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7226                    return getPersistence()
7227                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
7228            }
7229    
7230            /**
7231            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7232            *
7233            * <p>
7234            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7235            * </p>
7236            *
7237            * @param groupId the group ID
7238            * @param articleId the article ID
7239            * @param statuses the statuses
7240            * @param start the lower bound of the range of journal articles
7241            * @param end the upper bound of the range of journal articles (not inclusive)
7242            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7243            * @return the ordered range of matching journal articles
7244            * @throws SystemException if a system exception occurred
7245            */
7246            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7247                    long groupId, java.lang.String articleId, int[] statuses, int start,
7248                    int end,
7249                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7250                    throws com.liferay.portal.kernel.exception.SystemException {
7251                    return getPersistence()
7252                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
7253                            orderByComparator);
7254            }
7255    
7256            /**
7257            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
7258            *
7259            * @param groupId the group ID
7260            * @param articleId the article ID
7261            * @param status the status
7262            * @throws SystemException if a system exception occurred
7263            */
7264            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
7265                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7266                    getPersistence().removeByG_A_ST(groupId, articleId, status);
7267            }
7268    
7269            /**
7270            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7271            *
7272            * @param groupId the group ID
7273            * @param articleId the article ID
7274            * @param status the status
7275            * @return the number of matching journal articles
7276            * @throws SystemException if a system exception occurred
7277            */
7278            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7279                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7280                    return getPersistence().countByG_A_ST(groupId, articleId, status);
7281            }
7282    
7283            /**
7284            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7285            *
7286            * @param groupId the group ID
7287            * @param articleId the article ID
7288            * @param statuses the statuses
7289            * @return the number of matching journal articles
7290            * @throws SystemException if a system exception occurred
7291            */
7292            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7293                    int[] statuses)
7294                    throws com.liferay.portal.kernel.exception.SystemException {
7295                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
7296            }
7297    
7298            /**
7299            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7300            *
7301            * @param groupId the group ID
7302            * @param articleId the article ID
7303            * @param status the status
7304            * @return the number of matching journal articles that the user has permission to view
7305            * @throws SystemException if a system exception occurred
7306            */
7307            public static int filterCountByG_A_ST(long groupId,
7308                    java.lang.String articleId, int status)
7309                    throws com.liferay.portal.kernel.exception.SystemException {
7310                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
7311            }
7312    
7313            /**
7314            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7315            *
7316            * @param groupId the group ID
7317            * @param articleId the article ID
7318            * @param statuses the statuses
7319            * @return the number of matching journal articles that the user has permission to view
7320            * @throws SystemException if a system exception occurred
7321            */
7322            public static int filterCountByG_A_ST(long groupId,
7323                    java.lang.String articleId, int[] statuses)
7324                    throws com.liferay.portal.kernel.exception.SystemException {
7325                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
7326            }
7327    
7328            /**
7329            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7330            *
7331            * @param groupId the group ID
7332            * @param urlTitle the url title
7333            * @param status the status
7334            * @return the matching journal articles
7335            * @throws SystemException if a system exception occurred
7336            */
7337            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7338                    long groupId, java.lang.String urlTitle, int status)
7339                    throws com.liferay.portal.kernel.exception.SystemException {
7340                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
7341            }
7342    
7343            /**
7344            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7345            *
7346            * <p>
7347            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7348            * </p>
7349            *
7350            * @param groupId the group ID
7351            * @param urlTitle the url title
7352            * @param status the status
7353            * @param start the lower bound of the range of journal articles
7354            * @param end the upper bound of the range of journal articles (not inclusive)
7355            * @return the range of matching journal articles
7356            * @throws SystemException if a system exception occurred
7357            */
7358            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7359                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7360                    throws com.liferay.portal.kernel.exception.SystemException {
7361                    return getPersistence()
7362                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
7363            }
7364    
7365            /**
7366            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#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 urlTitle the url title
7374            * @param status the status
7375            * @param start the lower bound of the range of journal articles
7376            * @param end the upper bound of the range of journal articles (not inclusive)
7377            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7378            * @return the ordered range of matching journal articles
7379            * @throws SystemException if a system exception occurred
7380            */
7381            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7382                    long groupId, java.lang.String urlTitle, int status, int start,
7383                    int end,
7384                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7385                    throws com.liferay.portal.kernel.exception.SystemException {
7386                    return getPersistence()
7387                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
7388                            orderByComparator);
7389            }
7390    
7391            /**
7392            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7393            *
7394            * @param groupId the group ID
7395            * @param urlTitle the url title
7396            * @param status the status
7397            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7398            * @return the first matching journal article
7399            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7400            * @throws SystemException if a system exception occurred
7401            */
7402            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
7403                    long groupId, java.lang.String urlTitle, int status,
7404                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7405                    throws com.liferay.portal.kernel.exception.SystemException,
7406                            com.liferay.portlet.journal.NoSuchArticleException {
7407                    return getPersistence()
7408                                       .findByG_UT_ST_First(groupId, urlTitle, status,
7409                            orderByComparator);
7410            }
7411    
7412            /**
7413            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7414            *
7415            * @param groupId the group ID
7416            * @param urlTitle the url title
7417            * @param status the status
7418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7419            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7420            * @throws SystemException if a system exception occurred
7421            */
7422            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
7423                    long groupId, java.lang.String urlTitle, int status,
7424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7425                    throws com.liferay.portal.kernel.exception.SystemException {
7426                    return getPersistence()
7427                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
7428                            orderByComparator);
7429            }
7430    
7431            /**
7432            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7433            *
7434            * @param groupId the group ID
7435            * @param urlTitle the url title
7436            * @param status the status
7437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7438            * @return the last matching journal article
7439            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7440            * @throws SystemException if a system exception occurred
7441            */
7442            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
7443                    long groupId, java.lang.String urlTitle, int status,
7444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7445                    throws com.liferay.portal.kernel.exception.SystemException,
7446                            com.liferay.portlet.journal.NoSuchArticleException {
7447                    return getPersistence()
7448                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
7449                            orderByComparator);
7450            }
7451    
7452            /**
7453            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7454            *
7455            * @param groupId the group ID
7456            * @param urlTitle the url title
7457            * @param status the status
7458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7459            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7460            * @throws SystemException if a system exception occurred
7461            */
7462            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
7463                    long groupId, java.lang.String urlTitle, int status,
7464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7465                    throws com.liferay.portal.kernel.exception.SystemException {
7466                    return getPersistence()
7467                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
7468                            orderByComparator);
7469            }
7470    
7471            /**
7472            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7473            *
7474            * @param id the primary key of the current journal article
7475            * @param groupId the group ID
7476            * @param urlTitle the url title
7477            * @param status the status
7478            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7479            * @return the previous, current, and next journal article
7480            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7481            * @throws SystemException if a system exception occurred
7482            */
7483            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
7484                    long id, long groupId, java.lang.String urlTitle, int status,
7485                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7486                    throws com.liferay.portal.kernel.exception.SystemException,
7487                            com.liferay.portlet.journal.NoSuchArticleException {
7488                    return getPersistence()
7489                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
7490                            orderByComparator);
7491            }
7492    
7493            /**
7494            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7495            *
7496            * @param groupId the group ID
7497            * @param urlTitle the url title
7498            * @param status the status
7499            * @return the matching journal articles that the user has permission to view
7500            * @throws SystemException if a system exception occurred
7501            */
7502            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7503                    long groupId, java.lang.String urlTitle, int status)
7504                    throws com.liferay.portal.kernel.exception.SystemException {
7505                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
7506            }
7507    
7508            /**
7509            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7510            *
7511            * <p>
7512            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7513            * </p>
7514            *
7515            * @param groupId the group ID
7516            * @param urlTitle the url title
7517            * @param status the status
7518            * @param start the lower bound of the range of journal articles
7519            * @param end the upper bound of the range of journal articles (not inclusive)
7520            * @return the range of matching journal articles that the user has permission to view
7521            * @throws SystemException if a system exception occurred
7522            */
7523            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7524                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7525                    throws com.liferay.portal.kernel.exception.SystemException {
7526                    return getPersistence()
7527                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7528            }
7529    
7530            /**
7531            * 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;.
7532            *
7533            * <p>
7534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7535            * </p>
7536            *
7537            * @param groupId the group ID
7538            * @param urlTitle the url title
7539            * @param status the status
7540            * @param start the lower bound of the range of journal articles
7541            * @param end the upper bound of the range of journal articles (not inclusive)
7542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7543            * @return the ordered range of matching journal articles that the user has permission to view
7544            * @throws SystemException if a system exception occurred
7545            */
7546            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7547                    long groupId, java.lang.String urlTitle, int status, int start,
7548                    int end,
7549                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7550                    throws com.liferay.portal.kernel.exception.SystemException {
7551                    return getPersistence()
7552                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7553                            orderByComparator);
7554            }
7555    
7556            /**
7557            * 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;.
7558            *
7559            * @param id the primary key of the current journal article
7560            * @param groupId the group ID
7561            * @param urlTitle the url title
7562            * @param status the status
7563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7564            * @return the previous, current, and next journal article
7565            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7566            * @throws SystemException if a system exception occurred
7567            */
7568            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
7569                    long id, long groupId, java.lang.String urlTitle, int status,
7570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7571                    throws com.liferay.portal.kernel.exception.SystemException,
7572                            com.liferay.portlet.journal.NoSuchArticleException {
7573                    return getPersistence()
7574                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7575                            status, orderByComparator);
7576            }
7577    
7578            /**
7579            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7580            *
7581            * @param groupId the group ID
7582            * @param urlTitle the url title
7583            * @param status the status
7584            * @throws SystemException if a system exception occurred
7585            */
7586            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7587                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7588                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7589            }
7590    
7591            /**
7592            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7593            *
7594            * @param groupId the group ID
7595            * @param urlTitle the url title
7596            * @param status the status
7597            * @return the number of matching journal articles
7598            * @throws SystemException if a system exception occurred
7599            */
7600            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7601                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7602                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7603            }
7604    
7605            /**
7606            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7607            *
7608            * @param groupId the group ID
7609            * @param urlTitle the url title
7610            * @param status the status
7611            * @return the number of matching journal articles that the user has permission to view
7612            * @throws SystemException if a system exception occurred
7613            */
7614            public static int filterCountByG_UT_ST(long groupId,
7615                    java.lang.String urlTitle, int status)
7616                    throws com.liferay.portal.kernel.exception.SystemException {
7617                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7618            }
7619    
7620            /**
7621            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7622            *
7623            * @param companyId the company ID
7624            * @param version the version
7625            * @param status the status
7626            * @return the matching journal articles
7627            * @throws SystemException if a system exception occurred
7628            */
7629            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7630                    long companyId, double version, int status)
7631                    throws com.liferay.portal.kernel.exception.SystemException {
7632                    return getPersistence().findByC_V_ST(companyId, version, status);
7633            }
7634    
7635            /**
7636            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7637            *
7638            * <p>
7639            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7640            * </p>
7641            *
7642            * @param companyId the company ID
7643            * @param version the version
7644            * @param status the status
7645            * @param start the lower bound of the range of journal articles
7646            * @param end the upper bound of the range of journal articles (not inclusive)
7647            * @return the range of matching journal articles
7648            * @throws SystemException if a system exception occurred
7649            */
7650            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7651                    long companyId, double version, int status, int start, int end)
7652                    throws com.liferay.portal.kernel.exception.SystemException {
7653                    return getPersistence()
7654                                       .findByC_V_ST(companyId, version, status, start, end);
7655            }
7656    
7657            /**
7658            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7659            *
7660            * <p>
7661            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7662            * </p>
7663            *
7664            * @param companyId the company ID
7665            * @param version the version
7666            * @param status the status
7667            * @param start the lower bound of the range of journal articles
7668            * @param end the upper bound of the range of journal articles (not inclusive)
7669            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7670            * @return the ordered range of matching journal articles
7671            * @throws SystemException if a system exception occurred
7672            */
7673            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7674                    long companyId, double version, int status, int start, int end,
7675                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7676                    throws com.liferay.portal.kernel.exception.SystemException {
7677                    return getPersistence()
7678                                       .findByC_V_ST(companyId, version, status, start, end,
7679                            orderByComparator);
7680            }
7681    
7682            /**
7683            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7684            *
7685            * @param companyId the company ID
7686            * @param version the version
7687            * @param status the status
7688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7689            * @return the first matching journal article
7690            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7691            * @throws SystemException if a system exception occurred
7692            */
7693            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
7694                    long companyId, double version, int status,
7695                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7696                    throws com.liferay.portal.kernel.exception.SystemException,
7697                            com.liferay.portlet.journal.NoSuchArticleException {
7698                    return getPersistence()
7699                                       .findByC_V_ST_First(companyId, version, status,
7700                            orderByComparator);
7701            }
7702    
7703            /**
7704            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7705            *
7706            * @param companyId the company ID
7707            * @param version the version
7708            * @param status the status
7709            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7710            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7711            * @throws SystemException if a system exception occurred
7712            */
7713            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
7714                    long companyId, double version, int status,
7715                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7716                    throws com.liferay.portal.kernel.exception.SystemException {
7717                    return getPersistence()
7718                                       .fetchByC_V_ST_First(companyId, version, status,
7719                            orderByComparator);
7720            }
7721    
7722            /**
7723            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7724            *
7725            * @param companyId the company ID
7726            * @param version the version
7727            * @param status the status
7728            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7729            * @return the last matching journal article
7730            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7731            * @throws SystemException if a system exception occurred
7732            */
7733            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
7734                    long companyId, double version, int status,
7735                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7736                    throws com.liferay.portal.kernel.exception.SystemException,
7737                            com.liferay.portlet.journal.NoSuchArticleException {
7738                    return getPersistence()
7739                                       .findByC_V_ST_Last(companyId, version, status,
7740                            orderByComparator);
7741            }
7742    
7743            /**
7744            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7745            *
7746            * @param companyId the company ID
7747            * @param version the version
7748            * @param status the status
7749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7750            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7751            * @throws SystemException if a system exception occurred
7752            */
7753            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
7754                    long companyId, double version, int status,
7755                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7756                    throws com.liferay.portal.kernel.exception.SystemException {
7757                    return getPersistence()
7758                                       .fetchByC_V_ST_Last(companyId, version, status,
7759                            orderByComparator);
7760            }
7761    
7762            /**
7763            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7764            *
7765            * @param id the primary key of the current journal article
7766            * @param companyId the company ID
7767            * @param version the version
7768            * @param status the status
7769            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7770            * @return the previous, current, and next journal article
7771            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7772            * @throws SystemException if a system exception occurred
7773            */
7774            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
7775                    long id, long companyId, double version, int status,
7776                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7777                    throws com.liferay.portal.kernel.exception.SystemException,
7778                            com.liferay.portlet.journal.NoSuchArticleException {
7779                    return getPersistence()
7780                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7781                            orderByComparator);
7782            }
7783    
7784            /**
7785            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7786            *
7787            * @param companyId the company ID
7788            * @param version the version
7789            * @param status the status
7790            * @throws SystemException if a system exception occurred
7791            */
7792            public static void removeByC_V_ST(long companyId, double version, int status)
7793                    throws com.liferay.portal.kernel.exception.SystemException {
7794                    getPersistence().removeByC_V_ST(companyId, version, status);
7795            }
7796    
7797            /**
7798            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7799            *
7800            * @param companyId the company ID
7801            * @param version the version
7802            * @param status the status
7803            * @return the number of matching journal articles
7804            * @throws SystemException if a system exception occurred
7805            */
7806            public static int countByC_V_ST(long companyId, double version, int status)
7807                    throws com.liferay.portal.kernel.exception.SystemException {
7808                    return getPersistence().countByC_V_ST(companyId, version, status);
7809            }
7810    
7811            /**
7812            * Caches the journal article in the entity cache if it is enabled.
7813            *
7814            * @param journalArticle the journal article
7815            */
7816            public static void cacheResult(
7817                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7818                    getPersistence().cacheResult(journalArticle);
7819            }
7820    
7821            /**
7822            * Caches the journal articles in the entity cache if it is enabled.
7823            *
7824            * @param journalArticles the journal articles
7825            */
7826            public static void cacheResult(
7827                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
7828                    getPersistence().cacheResult(journalArticles);
7829            }
7830    
7831            /**
7832            * Creates a new journal article with the primary key. Does not add the journal article to the database.
7833            *
7834            * @param id the primary key for the new journal article
7835            * @return the new journal article
7836            */
7837            public static com.liferay.portlet.journal.model.JournalArticle create(
7838                    long id) {
7839                    return getPersistence().create(id);
7840            }
7841    
7842            /**
7843            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
7844            *
7845            * @param id the primary key of the journal article
7846            * @return the journal article that was removed
7847            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7848            * @throws SystemException if a system exception occurred
7849            */
7850            public static com.liferay.portlet.journal.model.JournalArticle remove(
7851                    long id)
7852                    throws com.liferay.portal.kernel.exception.SystemException,
7853                            com.liferay.portlet.journal.NoSuchArticleException {
7854                    return getPersistence().remove(id);
7855            }
7856    
7857            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
7858                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
7859                    throws com.liferay.portal.kernel.exception.SystemException {
7860                    return getPersistence().updateImpl(journalArticle);
7861            }
7862    
7863            /**
7864            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
7865            *
7866            * @param id the primary key of the journal article
7867            * @return the journal article
7868            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7869            * @throws SystemException if a system exception occurred
7870            */
7871            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
7872                    long id)
7873                    throws com.liferay.portal.kernel.exception.SystemException,
7874                            com.liferay.portlet.journal.NoSuchArticleException {
7875                    return getPersistence().findByPrimaryKey(id);
7876            }
7877    
7878            /**
7879            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
7880            *
7881            * @param id the primary key of the journal article
7882            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
7883            * @throws SystemException if a system exception occurred
7884            */
7885            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
7886                    long id) throws com.liferay.portal.kernel.exception.SystemException {
7887                    return getPersistence().fetchByPrimaryKey(id);
7888            }
7889    
7890            /**
7891            * Returns all the journal articles.
7892            *
7893            * @return the journal articles
7894            * @throws SystemException if a system exception occurred
7895            */
7896            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
7897                    throws com.liferay.portal.kernel.exception.SystemException {
7898                    return getPersistence().findAll();
7899            }
7900    
7901            /**
7902            * Returns a range of all the journal articles.
7903            *
7904            * <p>
7905            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7906            * </p>
7907            *
7908            * @param start the lower bound of the range of journal articles
7909            * @param end the upper bound of the range of journal articles (not inclusive)
7910            * @return the range of journal articles
7911            * @throws SystemException if a system exception occurred
7912            */
7913            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7914                    int start, int end)
7915                    throws com.liferay.portal.kernel.exception.SystemException {
7916                    return getPersistence().findAll(start, end);
7917            }
7918    
7919            /**
7920            * Returns an ordered range of all the journal articles.
7921            *
7922            * <p>
7923            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7924            * </p>
7925            *
7926            * @param start the lower bound of the range of journal articles
7927            * @param end the upper bound of the range of journal articles (not inclusive)
7928            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7929            * @return the ordered range of journal articles
7930            * @throws SystemException if a system exception occurred
7931            */
7932            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7933                    int start, int end,
7934                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7935                    throws com.liferay.portal.kernel.exception.SystemException {
7936                    return getPersistence().findAll(start, end, orderByComparator);
7937            }
7938    
7939            /**
7940            * Removes all the journal articles from the database.
7941            *
7942            * @throws SystemException if a system exception occurred
7943            */
7944            public static void removeAll()
7945                    throws com.liferay.portal.kernel.exception.SystemException {
7946                    getPersistence().removeAll();
7947            }
7948    
7949            /**
7950            * Returns the number of journal articles.
7951            *
7952            * @return the number of journal articles
7953            * @throws SystemException if a system exception occurred
7954            */
7955            public static int countAll()
7956                    throws com.liferay.portal.kernel.exception.SystemException {
7957                    return getPersistence().countAll();
7958            }
7959    
7960            public static JournalArticlePersistence getPersistence() {
7961                    if (_persistence == null) {
7962                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
7963    
7964                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
7965                                    "_persistence");
7966                    }
7967    
7968                    return _persistence;
7969            }
7970    
7971            /**
7972             * @deprecated As of 6.2.0
7973             */
7974            public void setPersistence(JournalArticlePersistence persistence) {
7975            }
7976    
7977            private static JournalArticlePersistence _persistence;
7978    }