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 aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.util.OrderByComparator;
023    import com.liferay.portal.kernel.util.ReferenceRegistry;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import com.liferay.portlet.journal.model.JournalArticle;
027    
028    import java.util.List;
029    
030    /**
031     * 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.
032     *
033     * <p>
034     * Caching information and settings can be found in <code>portal.properties</code>
035     * </p>
036     *
037     * @author Brian Wing Shun Chan
038     * @see JournalArticlePersistence
039     * @see JournalArticlePersistenceImpl
040     * @generated
041     */
042    @ProviderType
043    public class JournalArticleUtil {
044            /*
045             * NOTE FOR DEVELOPERS:
046             *
047             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
048             */
049    
050            /**
051             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
052             */
053            public static void clearCache() {
054                    getPersistence().clearCache();
055            }
056    
057            /**
058             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
059             */
060            public static void clearCache(JournalArticle journalArticle) {
061                    getPersistence().clearCache(journalArticle);
062            }
063    
064            /**
065             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
066             */
067            public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
068                    throws SystemException {
069                    return getPersistence().countWithDynamicQuery(dynamicQuery);
070            }
071    
072            /**
073             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
074             */
075            public static List<JournalArticle> findWithDynamicQuery(
076                    DynamicQuery dynamicQuery) throws SystemException {
077                    return getPersistence().findWithDynamicQuery(dynamicQuery);
078            }
079    
080            /**
081             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
082             */
083            public static List<JournalArticle> findWithDynamicQuery(
084                    DynamicQuery dynamicQuery, int start, int end)
085                    throws SystemException {
086                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
087            }
088    
089            /**
090             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
091             */
092            public static List<JournalArticle> findWithDynamicQuery(
093                    DynamicQuery dynamicQuery, int start, int end,
094                    OrderByComparator orderByComparator) throws SystemException {
095                    return getPersistence()
096                                       .findWithDynamicQuery(dynamicQuery, start, end,
097                            orderByComparator);
098            }
099    
100            /**
101             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
102             */
103            public static JournalArticle update(JournalArticle journalArticle)
104                    throws SystemException {
105                    return getPersistence().update(journalArticle);
106            }
107    
108            /**
109             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
110             */
111            public static JournalArticle update(JournalArticle journalArticle,
112                    ServiceContext serviceContext) throws SystemException {
113                    return getPersistence().update(journalArticle, serviceContext);
114            }
115    
116            /**
117            * Returns all the journal articles where uuid = &#63;.
118            *
119            * @param uuid the uuid
120            * @return the matching journal articles
121            * @throws SystemException if a system exception occurred
122            */
123            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
124                    java.lang.String uuid)
125                    throws com.liferay.portal.kernel.exception.SystemException {
126                    return getPersistence().findByUuid(uuid);
127            }
128    
129            /**
130            * Returns a range of all the journal articles where uuid = &#63;.
131            *
132            * <p>
133            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
134            * </p>
135            *
136            * @param uuid the uuid
137            * @param start the lower bound of the range of journal articles
138            * @param end the upper bound of the range of journal articles (not inclusive)
139            * @return the range of matching journal articles
140            * @throws SystemException if a system exception occurred
141            */
142            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
143                    java.lang.String uuid, int start, int end)
144                    throws com.liferay.portal.kernel.exception.SystemException {
145                    return getPersistence().findByUuid(uuid, start, end);
146            }
147    
148            /**
149            * Returns an ordered range of all the journal articles where uuid = &#63;.
150            *
151            * <p>
152            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
153            * </p>
154            *
155            * @param uuid the uuid
156            * @param start the lower bound of the range of journal articles
157            * @param end the upper bound of the range of journal articles (not inclusive)
158            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
159            * @return the ordered range of matching journal articles
160            * @throws SystemException if a system exception occurred
161            */
162            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
163                    java.lang.String uuid, int start, int end,
164                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
165                    throws com.liferay.portal.kernel.exception.SystemException {
166                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
167            }
168    
169            /**
170            * Returns the first journal article in the ordered set where uuid = &#63;.
171            *
172            * @param uuid the uuid
173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
174            * @return the first matching journal article
175            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
176            * @throws SystemException if a system exception occurred
177            */
178            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
179                    java.lang.String uuid,
180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
181                    throws com.liferay.portal.kernel.exception.SystemException,
182                            com.liferay.portlet.journal.NoSuchArticleException {
183                    return getPersistence().findByUuid_First(uuid, orderByComparator);
184            }
185    
186            /**
187            * Returns the first journal article in the ordered set where uuid = &#63;.
188            *
189            * @param uuid the uuid
190            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
191            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
192            * @throws SystemException if a system exception occurred
193            */
194            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First(
195                    java.lang.String uuid,
196                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
197                    throws com.liferay.portal.kernel.exception.SystemException {
198                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
199            }
200    
201            /**
202            * Returns the last journal article in the ordered set where uuid = &#63;.
203            *
204            * @param uuid the uuid
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the last matching journal article
207            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
208            * @throws SystemException if a system exception occurred
209            */
210            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
211                    java.lang.String uuid,
212                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
213                    throws com.liferay.portal.kernel.exception.SystemException,
214                            com.liferay.portlet.journal.NoSuchArticleException {
215                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
216            }
217    
218            /**
219            * Returns the last journal article in the ordered set where uuid = &#63;.
220            *
221            * @param uuid the uuid
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
224            * @throws SystemException if a system exception occurred
225            */
226            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last(
227                    java.lang.String uuid,
228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
229                    throws com.liferay.portal.kernel.exception.SystemException {
230                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
231            }
232    
233            /**
234            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
235            *
236            * @param id the primary key of the current journal article
237            * @param uuid the uuid
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next journal article
240            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
241            * @throws SystemException if a system exception occurred
242            */
243            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
244                    long id, java.lang.String uuid,
245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
246                    throws com.liferay.portal.kernel.exception.SystemException,
247                            com.liferay.portlet.journal.NoSuchArticleException {
248                    return getPersistence()
249                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
250            }
251    
252            /**
253            * Removes all the journal articles where uuid = &#63; from the database.
254            *
255            * @param uuid the uuid
256            * @throws SystemException if a system exception occurred
257            */
258            public static void removeByUuid(java.lang.String uuid)
259                    throws com.liferay.portal.kernel.exception.SystemException {
260                    getPersistence().removeByUuid(uuid);
261            }
262    
263            /**
264            * Returns the number of journal articles where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @return the number of matching journal articles
268            * @throws SystemException if a system exception occurred
269            */
270            public static int countByUuid(java.lang.String uuid)
271                    throws com.liferay.portal.kernel.exception.SystemException {
272                    return getPersistence().countByUuid(uuid);
273            }
274    
275            /**
276            * 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.
277            *
278            * @param uuid the uuid
279            * @param groupId the group ID
280            * @return the matching journal article
281            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
282            * @throws SystemException if a system exception occurred
283            */
284            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
285                    java.lang.String uuid, long groupId)
286                    throws com.liferay.portal.kernel.exception.SystemException,
287                            com.liferay.portlet.journal.NoSuchArticleException {
288                    return getPersistence().findByUUID_G(uuid, groupId);
289            }
290    
291            /**
292            * 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.
293            *
294            * @param uuid the uuid
295            * @param groupId the group ID
296            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
297            * @throws SystemException if a system exception occurred
298            */
299            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
300                    java.lang.String uuid, long groupId)
301                    throws com.liferay.portal.kernel.exception.SystemException {
302                    return getPersistence().fetchByUUID_G(uuid, groupId);
303            }
304    
305            /**
306            * 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.
307            *
308            * @param uuid the uuid
309            * @param groupId the group ID
310            * @param retrieveFromCache whether to use the finder cache
311            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
312            * @throws SystemException if a system exception occurred
313            */
314            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
315                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
316                    throws com.liferay.portal.kernel.exception.SystemException {
317                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
318            }
319    
320            /**
321            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
322            *
323            * @param uuid the uuid
324            * @param groupId the group ID
325            * @return the journal article that was removed
326            * @throws SystemException if a system exception occurred
327            */
328            public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G(
329                    java.lang.String uuid, long groupId)
330                    throws com.liferay.portal.kernel.exception.SystemException,
331                            com.liferay.portlet.journal.NoSuchArticleException {
332                    return getPersistence().removeByUUID_G(uuid, groupId);
333            }
334    
335            /**
336            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
337            *
338            * @param uuid the uuid
339            * @param groupId the group ID
340            * @return the number of matching journal articles
341            * @throws SystemException if a system exception occurred
342            */
343            public static int countByUUID_G(java.lang.String uuid, long groupId)
344                    throws com.liferay.portal.kernel.exception.SystemException {
345                    return getPersistence().countByUUID_G(uuid, groupId);
346            }
347    
348            /**
349            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
350            *
351            * @param uuid the uuid
352            * @param companyId the company ID
353            * @return the matching journal articles
354            * @throws SystemException if a system exception occurred
355            */
356            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
357                    java.lang.String uuid, long companyId)
358                    throws com.liferay.portal.kernel.exception.SystemException {
359                    return getPersistence().findByUuid_C(uuid, companyId);
360            }
361    
362            /**
363            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
364            *
365            * <p>
366            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
367            * </p>
368            *
369            * @param uuid the uuid
370            * @param companyId the company ID
371            * @param start the lower bound of the range of journal articles
372            * @param end the upper bound of the range of journal articles (not inclusive)
373            * @return the range of matching journal articles
374            * @throws SystemException if a system exception occurred
375            */
376            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
377                    java.lang.String uuid, long companyId, int start, int end)
378                    throws com.liferay.portal.kernel.exception.SystemException {
379                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
380            }
381    
382            /**
383            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
384            *
385            * <p>
386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
387            * </p>
388            *
389            * @param uuid the uuid
390            * @param companyId the company ID
391            * @param start the lower bound of the range of journal articles
392            * @param end the upper bound of the range of journal articles (not inclusive)
393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
394            * @return the ordered range of matching journal articles
395            * @throws SystemException if a system exception occurred
396            */
397            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
398                    java.lang.String uuid, long companyId, int start, int end,
399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
400                    throws com.liferay.portal.kernel.exception.SystemException {
401                    return getPersistence()
402                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
403            }
404    
405            /**
406            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the first matching journal article
412            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
413            * @throws SystemException if a system exception occurred
414            */
415            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First(
416                    java.lang.String uuid, long companyId,
417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
418                    throws com.liferay.portal.kernel.exception.SystemException,
419                            com.liferay.portlet.journal.NoSuchArticleException {
420                    return getPersistence()
421                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
422            }
423    
424            /**
425            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
426            *
427            * @param uuid the uuid
428            * @param companyId the company ID
429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
430            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
431            * @throws SystemException if a system exception occurred
432            */
433            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First(
434                    java.lang.String uuid, long companyId,
435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
436                    throws com.liferay.portal.kernel.exception.SystemException {
437                    return getPersistence()
438                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
439            }
440    
441            /**
442            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
443            *
444            * @param uuid the uuid
445            * @param companyId the company ID
446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
447            * @return the last matching journal article
448            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
449            * @throws SystemException if a system exception occurred
450            */
451            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last(
452                    java.lang.String uuid, long companyId,
453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.journal.NoSuchArticleException {
456                    return getPersistence()
457                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
458            }
459    
460            /**
461            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
462            *
463            * @param uuid the uuid
464            * @param companyId the company ID
465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
466            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
467            * @throws SystemException if a system exception occurred
468            */
469            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last(
470                    java.lang.String uuid, long companyId,
471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
472                    throws com.liferay.portal.kernel.exception.SystemException {
473                    return getPersistence()
474                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
475            }
476    
477            /**
478            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
479            *
480            * @param id the primary key of the current journal article
481            * @param uuid the uuid
482            * @param companyId the company ID
483            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
484            * @return the previous, current, and next journal article
485            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
486            * @throws SystemException if a system exception occurred
487            */
488            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext(
489                    long id, java.lang.String uuid, long companyId,
490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
491                    throws com.liferay.portal.kernel.exception.SystemException,
492                            com.liferay.portlet.journal.NoSuchArticleException {
493                    return getPersistence()
494                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
495                            orderByComparator);
496            }
497    
498            /**
499            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
500            *
501            * @param uuid the uuid
502            * @param companyId the company ID
503            * @throws SystemException if a system exception occurred
504            */
505            public static void removeByUuid_C(java.lang.String uuid, long companyId)
506                    throws com.liferay.portal.kernel.exception.SystemException {
507                    getPersistence().removeByUuid_C(uuid, companyId);
508            }
509    
510            /**
511            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
512            *
513            * @param uuid the uuid
514            * @param companyId the company ID
515            * @return the number of matching journal articles
516            * @throws SystemException if a system exception occurred
517            */
518            public static int countByUuid_C(java.lang.String uuid, long companyId)
519                    throws com.liferay.portal.kernel.exception.SystemException {
520                    return getPersistence().countByUuid_C(uuid, companyId);
521            }
522    
523            /**
524            * Returns all the journal articles where resourcePrimKey = &#63;.
525            *
526            * @param resourcePrimKey the resource prim key
527            * @return the matching journal articles
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
531                    long resourcePrimKey)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
534            }
535    
536            /**
537            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
538            *
539            * <p>
540            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
541            * </p>
542            *
543            * @param resourcePrimKey the resource prim key
544            * @param start the lower bound of the range of journal articles
545            * @param end the upper bound of the range of journal articles (not inclusive)
546            * @return the range of matching journal articles
547            * @throws SystemException if a system exception occurred
548            */
549            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
550                    long resourcePrimKey, int start, int end)
551                    throws com.liferay.portal.kernel.exception.SystemException {
552                    return getPersistence()
553                                       .findByResourcePrimKey(resourcePrimKey, start, end);
554            }
555    
556            /**
557            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
558            *
559            * <p>
560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
561            * </p>
562            *
563            * @param resourcePrimKey the resource prim key
564            * @param start the lower bound of the range of journal articles
565            * @param end the upper bound of the range of journal articles (not inclusive)
566            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
567            * @return the ordered range of matching journal articles
568            * @throws SystemException if a system exception occurred
569            */
570            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
571                    long resourcePrimKey, int start, int end,
572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
573                    throws com.liferay.portal.kernel.exception.SystemException {
574                    return getPersistence()
575                                       .findByResourcePrimKey(resourcePrimKey, start, end,
576                            orderByComparator);
577            }
578    
579            /**
580            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
581            *
582            * @param resourcePrimKey the resource prim key
583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
584            * @return the first matching journal article
585            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
586            * @throws SystemException if a system exception occurred
587            */
588            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
589                    long resourcePrimKey,
590                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
591                    throws com.liferay.portal.kernel.exception.SystemException,
592                            com.liferay.portlet.journal.NoSuchArticleException {
593                    return getPersistence()
594                                       .findByResourcePrimKey_First(resourcePrimKey,
595                            orderByComparator);
596            }
597    
598            /**
599            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
600            *
601            * @param resourcePrimKey the resource prim key
602            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
603            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
604            * @throws SystemException if a system exception occurred
605            */
606            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First(
607                    long resourcePrimKey,
608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
609                    throws com.liferay.portal.kernel.exception.SystemException {
610                    return getPersistence()
611                                       .fetchByResourcePrimKey_First(resourcePrimKey,
612                            orderByComparator);
613            }
614    
615            /**
616            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
617            *
618            * @param resourcePrimKey the resource prim key
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the last matching journal article
621            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
622            * @throws SystemException if a system exception occurred
623            */
624            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
625                    long resourcePrimKey,
626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
627                    throws com.liferay.portal.kernel.exception.SystemException,
628                            com.liferay.portlet.journal.NoSuchArticleException {
629                    return getPersistence()
630                                       .findByResourcePrimKey_Last(resourcePrimKey,
631                            orderByComparator);
632            }
633    
634            /**
635            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
636            *
637            * @param resourcePrimKey the resource prim key
638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
639            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
640            * @throws SystemException if a system exception occurred
641            */
642            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last(
643                    long resourcePrimKey,
644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
645                    throws com.liferay.portal.kernel.exception.SystemException {
646                    return getPersistence()
647                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
648                            orderByComparator);
649            }
650    
651            /**
652            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
653            *
654            * @param id the primary key of the current journal article
655            * @param resourcePrimKey the resource prim key
656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
657            * @return the previous, current, and next journal article
658            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
659            * @throws SystemException if a system exception occurred
660            */
661            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
662                    long id, long resourcePrimKey,
663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
664                    throws com.liferay.portal.kernel.exception.SystemException,
665                            com.liferay.portlet.journal.NoSuchArticleException {
666                    return getPersistence()
667                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
668                            orderByComparator);
669            }
670    
671            /**
672            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
673            *
674            * @param resourcePrimKey the resource prim key
675            * @throws SystemException if a system exception occurred
676            */
677            public static void removeByResourcePrimKey(long resourcePrimKey)
678                    throws com.liferay.portal.kernel.exception.SystemException {
679                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
680            }
681    
682            /**
683            * Returns the number of journal articles where resourcePrimKey = &#63;.
684            *
685            * @param resourcePrimKey the resource prim key
686            * @return the number of matching journal articles
687            * @throws SystemException if a system exception occurred
688            */
689            public static int countByResourcePrimKey(long resourcePrimKey)
690                    throws com.liferay.portal.kernel.exception.SystemException {
691                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
692            }
693    
694            /**
695            * Returns all the journal articles where groupId = &#63;.
696            *
697            * @param groupId the group ID
698            * @return the matching journal articles
699            * @throws SystemException if a system exception occurred
700            */
701            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
702                    long groupId)
703                    throws com.liferay.portal.kernel.exception.SystemException {
704                    return getPersistence().findByGroupId(groupId);
705            }
706    
707            /**
708            * Returns a range of all the journal articles where groupId = &#63;.
709            *
710            * <p>
711            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
712            * </p>
713            *
714            * @param groupId the group ID
715            * @param start the lower bound of the range of journal articles
716            * @param end the upper bound of the range of journal articles (not inclusive)
717            * @return the range of matching journal articles
718            * @throws SystemException if a system exception occurred
719            */
720            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
721                    long groupId, int start, int end)
722                    throws com.liferay.portal.kernel.exception.SystemException {
723                    return getPersistence().findByGroupId(groupId, start, end);
724            }
725    
726            /**
727            * Returns an ordered range of all the journal articles where groupId = &#63;.
728            *
729            * <p>
730            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
731            * </p>
732            *
733            * @param groupId the group ID
734            * @param start the lower bound of the range of journal articles
735            * @param end the upper bound of the range of journal articles (not inclusive)
736            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
737            * @return the ordered range of matching journal articles
738            * @throws SystemException if a system exception occurred
739            */
740            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
741                    long groupId, int start, int end,
742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
743                    throws com.liferay.portal.kernel.exception.SystemException {
744                    return getPersistence()
745                                       .findByGroupId(groupId, start, end, orderByComparator);
746            }
747    
748            /**
749            * Returns the first journal article in the ordered set where groupId = &#63;.
750            *
751            * @param groupId the group ID
752            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
753            * @return the first matching journal article
754            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
755            * @throws SystemException if a system exception occurred
756            */
757            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
758                    long groupId,
759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
760                    throws com.liferay.portal.kernel.exception.SystemException,
761                            com.liferay.portlet.journal.NoSuchArticleException {
762                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
763            }
764    
765            /**
766            * Returns the first journal article in the ordered set where groupId = &#63;.
767            *
768            * @param groupId the group ID
769            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
770            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
771            * @throws SystemException if a system exception occurred
772            */
773            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First(
774                    long groupId,
775                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
778            }
779    
780            /**
781            * Returns the last journal article in the ordered set where groupId = &#63;.
782            *
783            * @param groupId the group ID
784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
785            * @return the last matching journal article
786            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
787            * @throws SystemException if a system exception occurred
788            */
789            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
790                    long groupId,
791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
792                    throws com.liferay.portal.kernel.exception.SystemException,
793                            com.liferay.portlet.journal.NoSuchArticleException {
794                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
795            }
796    
797            /**
798            * Returns the last journal article in the ordered set where groupId = &#63;.
799            *
800            * @param groupId the group ID
801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
802            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
803            * @throws SystemException if a system exception occurred
804            */
805            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last(
806                    long groupId,
807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
808                    throws com.liferay.portal.kernel.exception.SystemException {
809                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
810            }
811    
812            /**
813            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
814            *
815            * @param id the primary key of the current journal article
816            * @param groupId the group ID
817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
818            * @return the previous, current, and next journal article
819            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
820            * @throws SystemException if a system exception occurred
821            */
822            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
823                    long id, long groupId,
824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
825                    throws com.liferay.portal.kernel.exception.SystemException,
826                            com.liferay.portlet.journal.NoSuchArticleException {
827                    return getPersistence()
828                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
829            }
830    
831            /**
832            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
833            *
834            * @param groupId the group ID
835            * @return the matching journal articles that the user has permission to view
836            * @throws SystemException if a system exception occurred
837            */
838            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
839                    long groupId)
840                    throws com.liferay.portal.kernel.exception.SystemException {
841                    return getPersistence().filterFindByGroupId(groupId);
842            }
843    
844            /**
845            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
846            *
847            * <p>
848            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
849            * </p>
850            *
851            * @param groupId the group ID
852            * @param start the lower bound of the range of journal articles
853            * @param end the upper bound of the range of journal articles (not inclusive)
854            * @return the range of matching journal articles that the user has permission to view
855            * @throws SystemException if a system exception occurred
856            */
857            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
858                    long groupId, int start, int end)
859                    throws com.liferay.portal.kernel.exception.SystemException {
860                    return getPersistence().filterFindByGroupId(groupId, start, end);
861            }
862    
863            /**
864            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
865            *
866            * <p>
867            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
868            * </p>
869            *
870            * @param groupId the group ID
871            * @param start the lower bound of the range of journal articles
872            * @param end the upper bound of the range of journal articles (not inclusive)
873            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
874            * @return the ordered range of matching journal articles that the user has permission to view
875            * @throws SystemException if a system exception occurred
876            */
877            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
878                    long groupId, int start, int end,
879                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
880                    throws com.liferay.portal.kernel.exception.SystemException {
881                    return getPersistence()
882                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
883            }
884    
885            /**
886            * 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;.
887            *
888            * @param id the primary key of the current journal article
889            * @param groupId the group ID
890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
891            * @return the previous, current, and next journal article
892            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
893            * @throws SystemException if a system exception occurred
894            */
895            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
896                    long id, long groupId,
897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
898                    throws com.liferay.portal.kernel.exception.SystemException,
899                            com.liferay.portlet.journal.NoSuchArticleException {
900                    return getPersistence()
901                                       .filterFindByGroupId_PrevAndNext(id, groupId,
902                            orderByComparator);
903            }
904    
905            /**
906            * Removes all the journal articles where groupId = &#63; from the database.
907            *
908            * @param groupId the group ID
909            * @throws SystemException if a system exception occurred
910            */
911            public static void removeByGroupId(long groupId)
912                    throws com.liferay.portal.kernel.exception.SystemException {
913                    getPersistence().removeByGroupId(groupId);
914            }
915    
916            /**
917            * Returns the number of journal articles where groupId = &#63;.
918            *
919            * @param groupId the group ID
920            * @return the number of matching journal articles
921            * @throws SystemException if a system exception occurred
922            */
923            public static int countByGroupId(long groupId)
924                    throws com.liferay.portal.kernel.exception.SystemException {
925                    return getPersistence().countByGroupId(groupId);
926            }
927    
928            /**
929            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
930            *
931            * @param groupId the group ID
932            * @return the number of matching journal articles that the user has permission to view
933            * @throws SystemException if a system exception occurred
934            */
935            public static int filterCountByGroupId(long groupId)
936                    throws com.liferay.portal.kernel.exception.SystemException {
937                    return getPersistence().filterCountByGroupId(groupId);
938            }
939    
940            /**
941            * Returns all the journal articles where companyId = &#63;.
942            *
943            * @param companyId the company ID
944            * @return the matching journal articles
945            * @throws SystemException if a system exception occurred
946            */
947            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
948                    long companyId)
949                    throws com.liferay.portal.kernel.exception.SystemException {
950                    return getPersistence().findByCompanyId(companyId);
951            }
952    
953            /**
954            * Returns a range of all the journal articles where companyId = &#63;.
955            *
956            * <p>
957            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
958            * </p>
959            *
960            * @param companyId the company ID
961            * @param start the lower bound of the range of journal articles
962            * @param end the upper bound of the range of journal articles (not inclusive)
963            * @return the range of matching journal articles
964            * @throws SystemException if a system exception occurred
965            */
966            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
967                    long companyId, int start, int end)
968                    throws com.liferay.portal.kernel.exception.SystemException {
969                    return getPersistence().findByCompanyId(companyId, start, end);
970            }
971    
972            /**
973            * Returns an ordered range of all the journal articles where companyId = &#63;.
974            *
975            * <p>
976            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
977            * </p>
978            *
979            * @param companyId the company ID
980            * @param start the lower bound of the range of journal articles
981            * @param end the upper bound of the range of journal articles (not inclusive)
982            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
983            * @return the ordered range of matching journal articles
984            * @throws SystemException if a system exception occurred
985            */
986            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
987                    long companyId, int start, int end,
988                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
989                    throws com.liferay.portal.kernel.exception.SystemException {
990                    return getPersistence()
991                                       .findByCompanyId(companyId, start, end, orderByComparator);
992            }
993    
994            /**
995            * Returns the first journal article in the ordered set where companyId = &#63;.
996            *
997            * @param companyId the company ID
998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
999            * @return the first matching journal article
1000            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1001            * @throws SystemException if a system exception occurred
1002            */
1003            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
1004                    long companyId,
1005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1006                    throws com.liferay.portal.kernel.exception.SystemException,
1007                            com.liferay.portlet.journal.NoSuchArticleException {
1008                    return getPersistence()
1009                                       .findByCompanyId_First(companyId, orderByComparator);
1010            }
1011    
1012            /**
1013            * Returns the first journal article in the ordered set where companyId = &#63;.
1014            *
1015            * @param companyId the company ID
1016            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1017            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1018            * @throws SystemException if a system exception occurred
1019            */
1020            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First(
1021                    long companyId,
1022                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1023                    throws com.liferay.portal.kernel.exception.SystemException {
1024                    return getPersistence()
1025                                       .fetchByCompanyId_First(companyId, orderByComparator);
1026            }
1027    
1028            /**
1029            * Returns the last journal article in the ordered set where companyId = &#63;.
1030            *
1031            * @param companyId the company ID
1032            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1033            * @return the last matching journal article
1034            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1035            * @throws SystemException if a system exception occurred
1036            */
1037            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
1038                    long companyId,
1039                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1040                    throws com.liferay.portal.kernel.exception.SystemException,
1041                            com.liferay.portlet.journal.NoSuchArticleException {
1042                    return getPersistence()
1043                                       .findByCompanyId_Last(companyId, orderByComparator);
1044            }
1045    
1046            /**
1047            * Returns the last journal article in the ordered set where companyId = &#63;.
1048            *
1049            * @param companyId the company ID
1050            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1051            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1052            * @throws SystemException if a system exception occurred
1053            */
1054            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last(
1055                    long companyId,
1056                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1057                    throws com.liferay.portal.kernel.exception.SystemException {
1058                    return getPersistence()
1059                                       .fetchByCompanyId_Last(companyId, orderByComparator);
1060            }
1061    
1062            /**
1063            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
1064            *
1065            * @param id the primary key of the current journal article
1066            * @param companyId the company ID
1067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1068            * @return the previous, current, and next journal article
1069            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
1073                    long id, long companyId,
1074                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1075                    throws com.liferay.portal.kernel.exception.SystemException,
1076                            com.liferay.portlet.journal.NoSuchArticleException {
1077                    return getPersistence()
1078                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
1079            }
1080    
1081            /**
1082            * Removes all the journal articles where companyId = &#63; from the database.
1083            *
1084            * @param companyId the company ID
1085            * @throws SystemException if a system exception occurred
1086            */
1087            public static void removeByCompanyId(long companyId)
1088                    throws com.liferay.portal.kernel.exception.SystemException {
1089                    getPersistence().removeByCompanyId(companyId);
1090            }
1091    
1092            /**
1093            * Returns the number of journal articles where companyId = &#63;.
1094            *
1095            * @param companyId the company ID
1096            * @return the number of matching journal articles
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static int countByCompanyId(long companyId)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    return getPersistence().countByCompanyId(companyId);
1102            }
1103    
1104            /**
1105            * Returns all the journal articles where structureId = &#63;.
1106            *
1107            * @param structureId the structure ID
1108            * @return the matching journal articles
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1112                    java.lang.String structureId)
1113                    throws com.liferay.portal.kernel.exception.SystemException {
1114                    return getPersistence().findByStructureId(structureId);
1115            }
1116    
1117            /**
1118            * Returns a range of all the journal articles where structureId = &#63;.
1119            *
1120            * <p>
1121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1122            * </p>
1123            *
1124            * @param structureId the structure ID
1125            * @param start the lower bound of the range of journal articles
1126            * @param end the upper bound of the range of journal articles (not inclusive)
1127            * @return the range of matching journal articles
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1131                    java.lang.String structureId, int start, int end)
1132                    throws com.liferay.portal.kernel.exception.SystemException {
1133                    return getPersistence().findByStructureId(structureId, start, end);
1134            }
1135    
1136            /**
1137            * Returns an ordered range of all the journal articles where structureId = &#63;.
1138            *
1139            * <p>
1140            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1141            * </p>
1142            *
1143            * @param structureId the structure ID
1144            * @param start the lower bound of the range of journal articles
1145            * @param end the upper bound of the range of journal articles (not inclusive)
1146            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1147            * @return the ordered range of matching journal articles
1148            * @throws SystemException if a system exception occurred
1149            */
1150            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1151                    java.lang.String structureId, int start, int end,
1152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1153                    throws com.liferay.portal.kernel.exception.SystemException {
1154                    return getPersistence()
1155                                       .findByStructureId(structureId, start, end, orderByComparator);
1156            }
1157    
1158            /**
1159            * Returns the first journal article in the ordered set where structureId = &#63;.
1160            *
1161            * @param structureId the structure ID
1162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1163            * @return the first matching journal article
1164            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1165            * @throws SystemException if a system exception occurred
1166            */
1167            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
1168                    java.lang.String structureId,
1169                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1170                    throws com.liferay.portal.kernel.exception.SystemException,
1171                            com.liferay.portlet.journal.NoSuchArticleException {
1172                    return getPersistence()
1173                                       .findByStructureId_First(structureId, orderByComparator);
1174            }
1175    
1176            /**
1177            * Returns the first journal article in the ordered set where structureId = &#63;.
1178            *
1179            * @param structureId the structure ID
1180            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1181            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First(
1185                    java.lang.String structureId,
1186                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1187                    throws com.liferay.portal.kernel.exception.SystemException {
1188                    return getPersistence()
1189                                       .fetchByStructureId_First(structureId, orderByComparator);
1190            }
1191    
1192            /**
1193            * Returns the last journal article in the ordered set where structureId = &#63;.
1194            *
1195            * @param structureId the structure ID
1196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1197            * @return the last matching journal article
1198            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1199            * @throws SystemException if a system exception occurred
1200            */
1201            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
1202                    java.lang.String structureId,
1203                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1204                    throws com.liferay.portal.kernel.exception.SystemException,
1205                            com.liferay.portlet.journal.NoSuchArticleException {
1206                    return getPersistence()
1207                                       .findByStructureId_Last(structureId, orderByComparator);
1208            }
1209    
1210            /**
1211            * Returns the last journal article in the ordered set where structureId = &#63;.
1212            *
1213            * @param structureId the structure ID
1214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1215            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1216            * @throws SystemException if a system exception occurred
1217            */
1218            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last(
1219                    java.lang.String structureId,
1220                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1221                    throws com.liferay.portal.kernel.exception.SystemException {
1222                    return getPersistence()
1223                                       .fetchByStructureId_Last(structureId, orderByComparator);
1224            }
1225    
1226            /**
1227            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
1228            *
1229            * @param id the primary key of the current journal article
1230            * @param structureId the structure ID
1231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1232            * @return the previous, current, and next journal article
1233            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1234            * @throws SystemException if a system exception occurred
1235            */
1236            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
1237                    long id, java.lang.String structureId,
1238                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1239                    throws com.liferay.portal.kernel.exception.SystemException,
1240                            com.liferay.portlet.journal.NoSuchArticleException {
1241                    return getPersistence()
1242                                       .findByStructureId_PrevAndNext(id, structureId,
1243                            orderByComparator);
1244            }
1245    
1246            /**
1247            * Returns all the journal articles where structureId = any &#63;.
1248            *
1249            * <p>
1250            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1251            * </p>
1252            *
1253            * @param structureIds the structure IDs
1254            * @return the matching journal articles
1255            * @throws SystemException if a system exception occurred
1256            */
1257            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1258                    java.lang.String[] structureIds)
1259                    throws com.liferay.portal.kernel.exception.SystemException {
1260                    return getPersistence().findByStructureId(structureIds);
1261            }
1262    
1263            /**
1264            * Returns a range of all the journal articles where structureId = any &#63;.
1265            *
1266            * <p>
1267            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1268            * </p>
1269            *
1270            * @param structureIds the structure IDs
1271            * @param start the lower bound of the range of journal articles
1272            * @param end the upper bound of the range of journal articles (not inclusive)
1273            * @return the range of matching journal articles
1274            * @throws SystemException if a system exception occurred
1275            */
1276            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1277                    java.lang.String[] structureIds, int start, int end)
1278                    throws com.liferay.portal.kernel.exception.SystemException {
1279                    return getPersistence().findByStructureId(structureIds, start, end);
1280            }
1281    
1282            /**
1283            * Returns an ordered range of all the journal articles where structureId = any &#63;.
1284            *
1285            * <p>
1286            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1287            * </p>
1288            *
1289            * @param structureIds the structure IDs
1290            * @param start the lower bound of the range of journal articles
1291            * @param end the upper bound of the range of journal articles (not inclusive)
1292            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1293            * @return the ordered range of matching journal articles
1294            * @throws SystemException if a system exception occurred
1295            */
1296            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1297                    java.lang.String[] structureIds, int start, int end,
1298                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1299                    throws com.liferay.portal.kernel.exception.SystemException {
1300                    return getPersistence()
1301                                       .findByStructureId(structureIds, start, end,
1302                            orderByComparator);
1303            }
1304    
1305            /**
1306            * Removes all the journal articles where structureId = &#63; from the database.
1307            *
1308            * @param structureId the structure ID
1309            * @throws SystemException if a system exception occurred
1310            */
1311            public static void removeByStructureId(java.lang.String structureId)
1312                    throws com.liferay.portal.kernel.exception.SystemException {
1313                    getPersistence().removeByStructureId(structureId);
1314            }
1315    
1316            /**
1317            * Returns the number of journal articles where structureId = &#63;.
1318            *
1319            * @param structureId the structure ID
1320            * @return the number of matching journal articles
1321            * @throws SystemException if a system exception occurred
1322            */
1323            public static int countByStructureId(java.lang.String structureId)
1324                    throws com.liferay.portal.kernel.exception.SystemException {
1325                    return getPersistence().countByStructureId(structureId);
1326            }
1327    
1328            /**
1329            * Returns the number of journal articles where structureId = any &#63;.
1330            *
1331            * @param structureIds the structure IDs
1332            * @return the number of matching journal articles
1333            * @throws SystemException if a system exception occurred
1334            */
1335            public static int countByStructureId(java.lang.String[] structureIds)
1336                    throws com.liferay.portal.kernel.exception.SystemException {
1337                    return getPersistence().countByStructureId(structureIds);
1338            }
1339    
1340            /**
1341            * Returns all the journal articles where templateId = &#63;.
1342            *
1343            * @param templateId the template ID
1344            * @return the matching journal articles
1345            * @throws SystemException if a system exception occurred
1346            */
1347            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1348                    java.lang.String templateId)
1349                    throws com.liferay.portal.kernel.exception.SystemException {
1350                    return getPersistence().findByTemplateId(templateId);
1351            }
1352    
1353            /**
1354            * Returns a range of all the journal articles where templateId = &#63;.
1355            *
1356            * <p>
1357            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1358            * </p>
1359            *
1360            * @param templateId the template ID
1361            * @param start the lower bound of the range of journal articles
1362            * @param end the upper bound of the range of journal articles (not inclusive)
1363            * @return the range of matching journal articles
1364            * @throws SystemException if a system exception occurred
1365            */
1366            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1367                    java.lang.String templateId, int start, int end)
1368                    throws com.liferay.portal.kernel.exception.SystemException {
1369                    return getPersistence().findByTemplateId(templateId, start, end);
1370            }
1371    
1372            /**
1373            * Returns an ordered range of all the journal articles where templateId = &#63;.
1374            *
1375            * <p>
1376            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1377            * </p>
1378            *
1379            * @param templateId the template ID
1380            * @param start the lower bound of the range of journal articles
1381            * @param end the upper bound of the range of journal articles (not inclusive)
1382            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1383            * @return the ordered range of matching journal articles
1384            * @throws SystemException if a system exception occurred
1385            */
1386            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1387                    java.lang.String templateId, int start, int end,
1388                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1389                    throws com.liferay.portal.kernel.exception.SystemException {
1390                    return getPersistence()
1391                                       .findByTemplateId(templateId, start, end, orderByComparator);
1392            }
1393    
1394            /**
1395            * Returns the first journal article in the ordered set where templateId = &#63;.
1396            *
1397            * @param templateId the template ID
1398            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1399            * @return the first matching journal article
1400            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1401            * @throws SystemException if a system exception occurred
1402            */
1403            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1404                    java.lang.String templateId,
1405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1406                    throws com.liferay.portal.kernel.exception.SystemException,
1407                            com.liferay.portlet.journal.NoSuchArticleException {
1408                    return getPersistence()
1409                                       .findByTemplateId_First(templateId, orderByComparator);
1410            }
1411    
1412            /**
1413            * Returns the first journal article in the ordered set where templateId = &#63;.
1414            *
1415            * @param templateId the template ID
1416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1417            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1418            * @throws SystemException if a system exception occurred
1419            */
1420            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1421                    java.lang.String templateId,
1422                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1423                    throws com.liferay.portal.kernel.exception.SystemException {
1424                    return getPersistence()
1425                                       .fetchByTemplateId_First(templateId, orderByComparator);
1426            }
1427    
1428            /**
1429            * Returns the last journal article in the ordered set where templateId = &#63;.
1430            *
1431            * @param templateId the template ID
1432            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1433            * @return the last matching journal article
1434            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1435            * @throws SystemException if a system exception occurred
1436            */
1437            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1438                    java.lang.String templateId,
1439                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1440                    throws com.liferay.portal.kernel.exception.SystemException,
1441                            com.liferay.portlet.journal.NoSuchArticleException {
1442                    return getPersistence()
1443                                       .findByTemplateId_Last(templateId, orderByComparator);
1444            }
1445    
1446            /**
1447            * Returns the last journal article in the ordered set where templateId = &#63;.
1448            *
1449            * @param templateId the template ID
1450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1451            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1455                    java.lang.String templateId,
1456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1457                    throws com.liferay.portal.kernel.exception.SystemException {
1458                    return getPersistence()
1459                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1460            }
1461    
1462            /**
1463            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1464            *
1465            * @param id the primary key of the current journal article
1466            * @param templateId the template ID
1467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1468            * @return the previous, current, and next journal article
1469            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1470            * @throws SystemException if a system exception occurred
1471            */
1472            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1473                    long id, java.lang.String templateId,
1474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1475                    throws com.liferay.portal.kernel.exception.SystemException,
1476                            com.liferay.portlet.journal.NoSuchArticleException {
1477                    return getPersistence()
1478                                       .findByTemplateId_PrevAndNext(id, templateId,
1479                            orderByComparator);
1480            }
1481    
1482            /**
1483            * Removes all the journal articles where templateId = &#63; from the database.
1484            *
1485            * @param templateId the template ID
1486            * @throws SystemException if a system exception occurred
1487            */
1488            public static void removeByTemplateId(java.lang.String templateId)
1489                    throws com.liferay.portal.kernel.exception.SystemException {
1490                    getPersistence().removeByTemplateId(templateId);
1491            }
1492    
1493            /**
1494            * Returns the number of journal articles where templateId = &#63;.
1495            *
1496            * @param templateId the template ID
1497            * @return the number of matching journal articles
1498            * @throws SystemException if a system exception occurred
1499            */
1500            public static int countByTemplateId(java.lang.String templateId)
1501                    throws com.liferay.portal.kernel.exception.SystemException {
1502                    return getPersistence().countByTemplateId(templateId);
1503            }
1504    
1505            /**
1506            * Returns all the journal articles where layoutUuid = &#63;.
1507            *
1508            * @param layoutUuid the layout uuid
1509            * @return the matching journal articles
1510            * @throws SystemException if a system exception occurred
1511            */
1512            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1513                    java.lang.String layoutUuid)
1514                    throws com.liferay.portal.kernel.exception.SystemException {
1515                    return getPersistence().findByLayoutUuid(layoutUuid);
1516            }
1517    
1518            /**
1519            * Returns a range of all the journal articles where layoutUuid = &#63;.
1520            *
1521            * <p>
1522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1523            * </p>
1524            *
1525            * @param layoutUuid the layout uuid
1526            * @param start the lower bound of the range of journal articles
1527            * @param end the upper bound of the range of journal articles (not inclusive)
1528            * @return the range of matching journal articles
1529            * @throws SystemException if a system exception occurred
1530            */
1531            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1532                    java.lang.String layoutUuid, int start, int end)
1533                    throws com.liferay.portal.kernel.exception.SystemException {
1534                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1535            }
1536    
1537            /**
1538            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1539            *
1540            * <p>
1541            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1542            * </p>
1543            *
1544            * @param layoutUuid the layout uuid
1545            * @param start the lower bound of the range of journal articles
1546            * @param end the upper bound of the range of journal articles (not inclusive)
1547            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1548            * @return the ordered range of matching journal articles
1549            * @throws SystemException if a system exception occurred
1550            */
1551            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1552                    java.lang.String layoutUuid, int start, int end,
1553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence()
1556                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1557            }
1558    
1559            /**
1560            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1561            *
1562            * @param layoutUuid the layout uuid
1563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1564            * @return the first matching journal article
1565            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1566            * @throws SystemException if a system exception occurred
1567            */
1568            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First(
1569                    java.lang.String layoutUuid,
1570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1571                    throws com.liferay.portal.kernel.exception.SystemException,
1572                            com.liferay.portlet.journal.NoSuchArticleException {
1573                    return getPersistence()
1574                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1575            }
1576    
1577            /**
1578            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1579            *
1580            * @param layoutUuid the layout uuid
1581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1582            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1583            * @throws SystemException if a system exception occurred
1584            */
1585            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First(
1586                    java.lang.String layoutUuid,
1587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1588                    throws com.liferay.portal.kernel.exception.SystemException {
1589                    return getPersistence()
1590                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1591            }
1592    
1593            /**
1594            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1595            *
1596            * @param layoutUuid the layout uuid
1597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1598            * @return the last matching journal article
1599            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1600            * @throws SystemException if a system exception occurred
1601            */
1602            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last(
1603                    java.lang.String layoutUuid,
1604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1605                    throws com.liferay.portal.kernel.exception.SystemException,
1606                            com.liferay.portlet.journal.NoSuchArticleException {
1607                    return getPersistence()
1608                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1609            }
1610    
1611            /**
1612            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1613            *
1614            * @param layoutUuid the layout uuid
1615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1616            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1617            * @throws SystemException if a system exception occurred
1618            */
1619            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last(
1620                    java.lang.String layoutUuid,
1621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1622                    throws com.liferay.portal.kernel.exception.SystemException {
1623                    return getPersistence()
1624                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1625            }
1626    
1627            /**
1628            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1629            *
1630            * @param id the primary key of the current journal article
1631            * @param layoutUuid the layout uuid
1632            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1633            * @return the previous, current, and next journal article
1634            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1635            * @throws SystemException if a system exception occurred
1636            */
1637            public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext(
1638                    long id, java.lang.String layoutUuid,
1639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1640                    throws com.liferay.portal.kernel.exception.SystemException,
1641                            com.liferay.portlet.journal.NoSuchArticleException {
1642                    return getPersistence()
1643                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1644                            orderByComparator);
1645            }
1646    
1647            /**
1648            * Removes all the journal articles where layoutUuid = &#63; from the database.
1649            *
1650            * @param layoutUuid the layout uuid
1651            * @throws SystemException if a system exception occurred
1652            */
1653            public static void removeByLayoutUuid(java.lang.String layoutUuid)
1654                    throws com.liferay.portal.kernel.exception.SystemException {
1655                    getPersistence().removeByLayoutUuid(layoutUuid);
1656            }
1657    
1658            /**
1659            * Returns the number of journal articles where layoutUuid = &#63;.
1660            *
1661            * @param layoutUuid the layout uuid
1662            * @return the number of matching journal articles
1663            * @throws SystemException if a system exception occurred
1664            */
1665            public static int countByLayoutUuid(java.lang.String layoutUuid)
1666                    throws com.liferay.portal.kernel.exception.SystemException {
1667                    return getPersistence().countByLayoutUuid(layoutUuid);
1668            }
1669    
1670            /**
1671            * Returns all the journal articles where smallImageId = &#63;.
1672            *
1673            * @param smallImageId the small image ID
1674            * @return the matching journal articles
1675            * @throws SystemException if a system exception occurred
1676            */
1677            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1678                    long smallImageId)
1679                    throws com.liferay.portal.kernel.exception.SystemException {
1680                    return getPersistence().findBySmallImageId(smallImageId);
1681            }
1682    
1683            /**
1684            * Returns a range of all the journal articles where smallImageId = &#63;.
1685            *
1686            * <p>
1687            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1688            * </p>
1689            *
1690            * @param smallImageId the small image ID
1691            * @param start the lower bound of the range of journal articles
1692            * @param end the upper bound of the range of journal articles (not inclusive)
1693            * @return the range of matching journal articles
1694            * @throws SystemException if a system exception occurred
1695            */
1696            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1697                    long smallImageId, int start, int end)
1698                    throws com.liferay.portal.kernel.exception.SystemException {
1699                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1700            }
1701    
1702            /**
1703            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1704            *
1705            * <p>
1706            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1707            * </p>
1708            *
1709            * @param smallImageId the small image ID
1710            * @param start the lower bound of the range of journal articles
1711            * @param end the upper bound of the range of journal articles (not inclusive)
1712            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1713            * @return the ordered range of matching journal articles
1714            * @throws SystemException if a system exception occurred
1715            */
1716            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1717                    long smallImageId, int start, int end,
1718                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1719                    throws com.liferay.portal.kernel.exception.SystemException {
1720                    return getPersistence()
1721                                       .findBySmallImageId(smallImageId, start, end,
1722                            orderByComparator);
1723            }
1724    
1725            /**
1726            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1727            *
1728            * @param smallImageId the small image ID
1729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1730            * @return the first matching journal article
1731            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1732            * @throws SystemException if a system exception occurred
1733            */
1734            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1735                    long smallImageId,
1736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1737                    throws com.liferay.portal.kernel.exception.SystemException,
1738                            com.liferay.portlet.journal.NoSuchArticleException {
1739                    return getPersistence()
1740                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1741            }
1742    
1743            /**
1744            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1745            *
1746            * @param smallImageId the small image ID
1747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1748            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1749            * @throws SystemException if a system exception occurred
1750            */
1751            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1752                    long smallImageId,
1753                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1754                    throws com.liferay.portal.kernel.exception.SystemException {
1755                    return getPersistence()
1756                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1757            }
1758    
1759            /**
1760            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1761            *
1762            * @param smallImageId the small image ID
1763            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1764            * @return the last matching journal article
1765            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1766            * @throws SystemException if a system exception occurred
1767            */
1768            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1769                    long smallImageId,
1770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1771                    throws com.liferay.portal.kernel.exception.SystemException,
1772                            com.liferay.portlet.journal.NoSuchArticleException {
1773                    return getPersistence()
1774                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1775            }
1776    
1777            /**
1778            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1779            *
1780            * @param smallImageId the small image ID
1781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1782            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1783            * @throws SystemException if a system exception occurred
1784            */
1785            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1786                    long smallImageId,
1787                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1788                    throws com.liferay.portal.kernel.exception.SystemException {
1789                    return getPersistence()
1790                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1791            }
1792    
1793            /**
1794            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1795            *
1796            * @param id the primary key of the current journal article
1797            * @param smallImageId the small image ID
1798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1799            * @return the previous, current, and next journal article
1800            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1801            * @throws SystemException if a system exception occurred
1802            */
1803            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1804                    long id, long smallImageId,
1805                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1806                    throws com.liferay.portal.kernel.exception.SystemException,
1807                            com.liferay.portlet.journal.NoSuchArticleException {
1808                    return getPersistence()
1809                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1810                            orderByComparator);
1811            }
1812    
1813            /**
1814            * Removes all the journal articles where smallImageId = &#63; from the database.
1815            *
1816            * @param smallImageId the small image ID
1817            * @throws SystemException if a system exception occurred
1818            */
1819            public static void removeBySmallImageId(long smallImageId)
1820                    throws com.liferay.portal.kernel.exception.SystemException {
1821                    getPersistence().removeBySmallImageId(smallImageId);
1822            }
1823    
1824            /**
1825            * Returns the number of journal articles where smallImageId = &#63;.
1826            *
1827            * @param smallImageId the small image ID
1828            * @return the number of matching journal articles
1829            * @throws SystemException if a system exception occurred
1830            */
1831            public static int countBySmallImageId(long smallImageId)
1832                    throws com.liferay.portal.kernel.exception.SystemException {
1833                    return getPersistence().countBySmallImageId(smallImageId);
1834            }
1835    
1836            /**
1837            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1838            *
1839            * @param resourcePrimKey the resource prim key
1840            * @param indexable the indexable
1841            * @return the matching journal articles
1842            * @throws SystemException if a system exception occurred
1843            */
1844            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1845                    long resourcePrimKey, boolean indexable)
1846                    throws com.liferay.portal.kernel.exception.SystemException {
1847                    return getPersistence().findByR_I(resourcePrimKey, indexable);
1848            }
1849    
1850            /**
1851            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1852            *
1853            * <p>
1854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1855            * </p>
1856            *
1857            * @param resourcePrimKey the resource prim key
1858            * @param indexable the indexable
1859            * @param start the lower bound of the range of journal articles
1860            * @param end the upper bound of the range of journal articles (not inclusive)
1861            * @return the range of matching journal articles
1862            * @throws SystemException if a system exception occurred
1863            */
1864            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1865                    long resourcePrimKey, boolean indexable, int start, int end)
1866                    throws com.liferay.portal.kernel.exception.SystemException {
1867                    return getPersistence().findByR_I(resourcePrimKey, indexable, start, end);
1868            }
1869    
1870            /**
1871            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1872            *
1873            * <p>
1874            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1875            * </p>
1876            *
1877            * @param resourcePrimKey the resource prim key
1878            * @param indexable the indexable
1879            * @param start the lower bound of the range of journal articles
1880            * @param end the upper bound of the range of journal articles (not inclusive)
1881            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1882            * @return the ordered range of matching journal articles
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1886                    long resourcePrimKey, boolean indexable, int start, int end,
1887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1888                    throws com.liferay.portal.kernel.exception.SystemException {
1889                    return getPersistence()
1890                                       .findByR_I(resourcePrimKey, indexable, start, end,
1891                            orderByComparator);
1892            }
1893    
1894            /**
1895            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1896            *
1897            * @param resourcePrimKey the resource prim key
1898            * @param indexable the indexable
1899            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1900            * @return the first matching journal article
1901            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1902            * @throws SystemException if a system exception occurred
1903            */
1904            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_First(
1905                    long resourcePrimKey, boolean indexable,
1906                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1907                    throws com.liferay.portal.kernel.exception.SystemException,
1908                            com.liferay.portlet.journal.NoSuchArticleException {
1909                    return getPersistence()
1910                                       .findByR_I_First(resourcePrimKey, indexable,
1911                            orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1916            *
1917            * @param resourcePrimKey the resource prim key
1918            * @param indexable the indexable
1919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1920            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1921            * @throws SystemException if a system exception occurred
1922            */
1923            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_First(
1924                    long resourcePrimKey, boolean indexable,
1925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1926                    throws com.liferay.portal.kernel.exception.SystemException {
1927                    return getPersistence()
1928                                       .fetchByR_I_First(resourcePrimKey, indexable,
1929                            orderByComparator);
1930            }
1931    
1932            /**
1933            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1934            *
1935            * @param resourcePrimKey the resource prim key
1936            * @param indexable the indexable
1937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1938            * @return the last matching journal article
1939            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1940            * @throws SystemException if a system exception occurred
1941            */
1942            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_Last(
1943                    long resourcePrimKey, boolean indexable,
1944                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1945                    throws com.liferay.portal.kernel.exception.SystemException,
1946                            com.liferay.portlet.journal.NoSuchArticleException {
1947                    return getPersistence()
1948                                       .findByR_I_Last(resourcePrimKey, indexable, orderByComparator);
1949            }
1950    
1951            /**
1952            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1953            *
1954            * @param resourcePrimKey the resource prim key
1955            * @param indexable the indexable
1956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1957            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1958            * @throws SystemException if a system exception occurred
1959            */
1960            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_Last(
1961                    long resourcePrimKey, boolean indexable,
1962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1963                    throws com.liferay.portal.kernel.exception.SystemException {
1964                    return getPersistence()
1965                                       .fetchByR_I_Last(resourcePrimKey, indexable,
1966                            orderByComparator);
1967            }
1968    
1969            /**
1970            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1971            *
1972            * @param id the primary key of the current journal article
1973            * @param resourcePrimKey the resource prim key
1974            * @param indexable the indexable
1975            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1976            * @return the previous, current, and next journal article
1977            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1978            * @throws SystemException if a system exception occurred
1979            */
1980            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_PrevAndNext(
1981                    long id, long resourcePrimKey, boolean indexable,
1982                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1983                    throws com.liferay.portal.kernel.exception.SystemException,
1984                            com.liferay.portlet.journal.NoSuchArticleException {
1985                    return getPersistence()
1986                                       .findByR_I_PrevAndNext(id, resourcePrimKey, indexable,
1987                            orderByComparator);
1988            }
1989    
1990            /**
1991            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; from the database.
1992            *
1993            * @param resourcePrimKey the resource prim key
1994            * @param indexable the indexable
1995            * @throws SystemException if a system exception occurred
1996            */
1997            public static void removeByR_I(long resourcePrimKey, boolean indexable)
1998                    throws com.liferay.portal.kernel.exception.SystemException {
1999                    getPersistence().removeByR_I(resourcePrimKey, indexable);
2000            }
2001    
2002            /**
2003            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63;.
2004            *
2005            * @param resourcePrimKey the resource prim key
2006            * @param indexable the indexable
2007            * @return the number of matching journal articles
2008            * @throws SystemException if a system exception occurred
2009            */
2010            public static int countByR_I(long resourcePrimKey, boolean indexable)
2011                    throws com.liferay.portal.kernel.exception.SystemException {
2012                    return getPersistence().countByR_I(resourcePrimKey, indexable);
2013            }
2014    
2015            /**
2016            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2017            *
2018            * @param resourcePrimKey the resource prim key
2019            * @param status the status
2020            * @return the matching journal articles
2021            * @throws SystemException if a system exception occurred
2022            */
2023            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2024                    long resourcePrimKey, int status)
2025                    throws com.liferay.portal.kernel.exception.SystemException {
2026                    return getPersistence().findByR_ST(resourcePrimKey, status);
2027            }
2028    
2029            /**
2030            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2031            *
2032            * <p>
2033            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2034            * </p>
2035            *
2036            * @param resourcePrimKey the resource prim key
2037            * @param status the status
2038            * @param start the lower bound of the range of journal articles
2039            * @param end the upper bound of the range of journal articles (not inclusive)
2040            * @return the range of matching journal articles
2041            * @throws SystemException if a system exception occurred
2042            */
2043            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2044                    long resourcePrimKey, int status, int start, int end)
2045                    throws com.liferay.portal.kernel.exception.SystemException {
2046                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
2047            }
2048    
2049            /**
2050            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2051            *
2052            * <p>
2053            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2054            * </p>
2055            *
2056            * @param resourcePrimKey the resource prim key
2057            * @param status the status
2058            * @param start the lower bound of the range of journal articles
2059            * @param end the upper bound of the range of journal articles (not inclusive)
2060            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2061            * @return the ordered range of matching journal articles
2062            * @throws SystemException if a system exception occurred
2063            */
2064            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2065                    long resourcePrimKey, int status, int start, int end,
2066                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2067                    throws com.liferay.portal.kernel.exception.SystemException {
2068                    return getPersistence()
2069                                       .findByR_ST(resourcePrimKey, status, start, end,
2070                            orderByComparator);
2071            }
2072    
2073            /**
2074            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2075            *
2076            * @param resourcePrimKey the resource prim key
2077            * @param status the status
2078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2079            * @return the first matching journal article
2080            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2081            * @throws SystemException if a system exception occurred
2082            */
2083            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
2084                    long resourcePrimKey, int status,
2085                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2086                    throws com.liferay.portal.kernel.exception.SystemException,
2087                            com.liferay.portlet.journal.NoSuchArticleException {
2088                    return getPersistence()
2089                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
2090            }
2091    
2092            /**
2093            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2094            *
2095            * @param resourcePrimKey the resource prim key
2096            * @param status the status
2097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2098            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2099            * @throws SystemException if a system exception occurred
2100            */
2101            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
2102                    long resourcePrimKey, int status,
2103                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2104                    throws com.liferay.portal.kernel.exception.SystemException {
2105                    return getPersistence()
2106                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
2107            }
2108    
2109            /**
2110            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2111            *
2112            * @param resourcePrimKey the resource prim key
2113            * @param status the status
2114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2115            * @return the last matching journal article
2116            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2117            * @throws SystemException if a system exception occurred
2118            */
2119            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
2120                    long resourcePrimKey, int status,
2121                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2122                    throws com.liferay.portal.kernel.exception.SystemException,
2123                            com.liferay.portlet.journal.NoSuchArticleException {
2124                    return getPersistence()
2125                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
2126            }
2127    
2128            /**
2129            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2130            *
2131            * @param resourcePrimKey the resource prim key
2132            * @param status the status
2133            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2134            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2135            * @throws SystemException if a system exception occurred
2136            */
2137            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
2138                    long resourcePrimKey, int status,
2139                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2140                    throws com.liferay.portal.kernel.exception.SystemException {
2141                    return getPersistence()
2142                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
2143            }
2144    
2145            /**
2146            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2147            *
2148            * @param id the primary key of the current journal article
2149            * @param resourcePrimKey the resource prim key
2150            * @param status the status
2151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2152            * @return the previous, current, and next journal article
2153            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2154            * @throws SystemException if a system exception occurred
2155            */
2156            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
2157                    long id, long resourcePrimKey, int status,
2158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2159                    throws com.liferay.portal.kernel.exception.SystemException,
2160                            com.liferay.portlet.journal.NoSuchArticleException {
2161                    return getPersistence()
2162                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
2163                            orderByComparator);
2164            }
2165    
2166            /**
2167            * Returns all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
2168            *
2169            * <p>
2170            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2171            * </p>
2172            *
2173            * @param resourcePrimKey the resource prim key
2174            * @param statuses the statuses
2175            * @return the matching journal articles
2176            * @throws SystemException if a system exception occurred
2177            */
2178            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2179                    long resourcePrimKey, int[] statuses)
2180                    throws com.liferay.portal.kernel.exception.SystemException {
2181                    return getPersistence().findByR_ST(resourcePrimKey, statuses);
2182            }
2183    
2184            /**
2185            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
2186            *
2187            * <p>
2188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2189            * </p>
2190            *
2191            * @param resourcePrimKey the resource prim key
2192            * @param statuses the statuses
2193            * @param start the lower bound of the range of journal articles
2194            * @param end the upper bound of the range of journal articles (not inclusive)
2195            * @return the range of matching journal articles
2196            * @throws SystemException if a system exception occurred
2197            */
2198            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2199                    long resourcePrimKey, int[] statuses, int start, int end)
2200                    throws com.liferay.portal.kernel.exception.SystemException {
2201                    return getPersistence().findByR_ST(resourcePrimKey, statuses, start, end);
2202            }
2203    
2204            /**
2205            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
2206            *
2207            * <p>
2208            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2209            * </p>
2210            *
2211            * @param resourcePrimKey the resource prim key
2212            * @param statuses the statuses
2213            * @param start the lower bound of the range of journal articles
2214            * @param end the upper bound of the range of journal articles (not inclusive)
2215            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2216            * @return the ordered range of matching journal articles
2217            * @throws SystemException if a system exception occurred
2218            */
2219            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2220                    long resourcePrimKey, int[] statuses, int start, int end,
2221                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2222                    throws com.liferay.portal.kernel.exception.SystemException {
2223                    return getPersistence()
2224                                       .findByR_ST(resourcePrimKey, statuses, start, end,
2225                            orderByComparator);
2226            }
2227    
2228            /**
2229            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
2230            *
2231            * @param resourcePrimKey the resource prim key
2232            * @param status the status
2233            * @throws SystemException if a system exception occurred
2234            */
2235            public static void removeByR_ST(long resourcePrimKey, int status)
2236                    throws com.liferay.portal.kernel.exception.SystemException {
2237                    getPersistence().removeByR_ST(resourcePrimKey, status);
2238            }
2239    
2240            /**
2241            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
2242            *
2243            * @param resourcePrimKey the resource prim key
2244            * @param status the status
2245            * @return the number of matching journal articles
2246            * @throws SystemException if a system exception occurred
2247            */
2248            public static int countByR_ST(long resourcePrimKey, int status)
2249                    throws com.liferay.portal.kernel.exception.SystemException {
2250                    return getPersistence().countByR_ST(resourcePrimKey, status);
2251            }
2252    
2253            /**
2254            * Returns the number of journal articles where resourcePrimKey = &#63; and status = any &#63;.
2255            *
2256            * @param resourcePrimKey the resource prim key
2257            * @param statuses the statuses
2258            * @return the number of matching journal articles
2259            * @throws SystemException if a system exception occurred
2260            */
2261            public static int countByR_ST(long resourcePrimKey, int[] statuses)
2262                    throws com.liferay.portal.kernel.exception.SystemException {
2263                    return getPersistence().countByR_ST(resourcePrimKey, statuses);
2264            }
2265    
2266            /**
2267            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
2268            *
2269            * @param groupId the group ID
2270            * @param userId the user ID
2271            * @return the matching journal articles
2272            * @throws SystemException if a system exception occurred
2273            */
2274            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2275                    long groupId, long userId)
2276                    throws com.liferay.portal.kernel.exception.SystemException {
2277                    return getPersistence().findByG_U(groupId, userId);
2278            }
2279    
2280            /**
2281            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
2282            *
2283            * <p>
2284            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2285            * </p>
2286            *
2287            * @param groupId the group ID
2288            * @param userId the user ID
2289            * @param start the lower bound of the range of journal articles
2290            * @param end the upper bound of the range of journal articles (not inclusive)
2291            * @return the range of matching journal articles
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2295                    long groupId, long userId, int start, int end)
2296                    throws com.liferay.portal.kernel.exception.SystemException {
2297                    return getPersistence().findByG_U(groupId, userId, start, end);
2298            }
2299    
2300            /**
2301            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
2302            *
2303            * <p>
2304            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2305            * </p>
2306            *
2307            * @param groupId the group ID
2308            * @param userId the user ID
2309            * @param start the lower bound of the range of journal articles
2310            * @param end the upper bound of the range of journal articles (not inclusive)
2311            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2312            * @return the ordered range of matching journal articles
2313            * @throws SystemException if a system exception occurred
2314            */
2315            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2316                    long groupId, long userId, int start, int end,
2317                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2318                    throws com.liferay.portal.kernel.exception.SystemException {
2319                    return getPersistence()
2320                                       .findByG_U(groupId, userId, start, end, orderByComparator);
2321            }
2322    
2323            /**
2324            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2325            *
2326            * @param groupId the group ID
2327            * @param userId the user ID
2328            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2329            * @return the first matching journal article
2330            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2331            * @throws SystemException if a system exception occurred
2332            */
2333            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First(
2334                    long groupId, long userId,
2335                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2336                    throws com.liferay.portal.kernel.exception.SystemException,
2337                            com.liferay.portlet.journal.NoSuchArticleException {
2338                    return getPersistence()
2339                                       .findByG_U_First(groupId, userId, orderByComparator);
2340            }
2341    
2342            /**
2343            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2344            *
2345            * @param groupId the group ID
2346            * @param userId the user ID
2347            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2348            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2349            * @throws SystemException if a system exception occurred
2350            */
2351            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First(
2352                    long groupId, long userId,
2353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2354                    throws com.liferay.portal.kernel.exception.SystemException {
2355                    return getPersistence()
2356                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2357            }
2358    
2359            /**
2360            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2361            *
2362            * @param groupId the group ID
2363            * @param userId the user ID
2364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2365            * @return the last matching journal article
2366            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2367            * @throws SystemException if a system exception occurred
2368            */
2369            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last(
2370                    long groupId, long userId,
2371                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2372                    throws com.liferay.portal.kernel.exception.SystemException,
2373                            com.liferay.portlet.journal.NoSuchArticleException {
2374                    return getPersistence()
2375                                       .findByG_U_Last(groupId, userId, orderByComparator);
2376            }
2377    
2378            /**
2379            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2380            *
2381            * @param groupId the group ID
2382            * @param userId the user ID
2383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2384            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2385            * @throws SystemException if a system exception occurred
2386            */
2387            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last(
2388                    long groupId, long userId,
2389                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2390                    throws com.liferay.portal.kernel.exception.SystemException {
2391                    return getPersistence()
2392                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2393            }
2394    
2395            /**
2396            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2397            *
2398            * @param id the primary key of the current journal article
2399            * @param groupId the group ID
2400            * @param userId the user ID
2401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2402            * @return the previous, current, and next journal article
2403            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2404            * @throws SystemException if a system exception occurred
2405            */
2406            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext(
2407                    long id, long groupId, long userId,
2408                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2409                    throws com.liferay.portal.kernel.exception.SystemException,
2410                            com.liferay.portlet.journal.NoSuchArticleException {
2411                    return getPersistence()
2412                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2413            }
2414    
2415            /**
2416            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2417            *
2418            * @param groupId the group ID
2419            * @param userId the user ID
2420            * @return the matching journal articles that the user has permission to view
2421            * @throws SystemException if a system exception occurred
2422            */
2423            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2424                    long groupId, long userId)
2425                    throws com.liferay.portal.kernel.exception.SystemException {
2426                    return getPersistence().filterFindByG_U(groupId, userId);
2427            }
2428    
2429            /**
2430            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2431            *
2432            * <p>
2433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2434            * </p>
2435            *
2436            * @param groupId the group ID
2437            * @param userId the user ID
2438            * @param start the lower bound of the range of journal articles
2439            * @param end the upper bound of the range of journal articles (not inclusive)
2440            * @return the range of matching journal articles that the user has permission to view
2441            * @throws SystemException if a system exception occurred
2442            */
2443            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2444                    long groupId, long userId, int start, int end)
2445                    throws com.liferay.portal.kernel.exception.SystemException {
2446                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2447            }
2448    
2449            /**
2450            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2451            *
2452            * <p>
2453            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2454            * </p>
2455            *
2456            * @param groupId the group ID
2457            * @param userId the user ID
2458            * @param start the lower bound of the range of journal articles
2459            * @param end the upper bound of the range of journal articles (not inclusive)
2460            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2461            * @return the ordered range of matching journal articles that the user has permission to view
2462            * @throws SystemException if a system exception occurred
2463            */
2464            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2465                    long groupId, long userId, int start, int end,
2466                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2467                    throws com.liferay.portal.kernel.exception.SystemException {
2468                    return getPersistence()
2469                                       .filterFindByG_U(groupId, userId, start, end,
2470                            orderByComparator);
2471            }
2472    
2473            /**
2474            * 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;.
2475            *
2476            * @param id the primary key of the current journal article
2477            * @param groupId the group ID
2478            * @param userId the user ID
2479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2480            * @return the previous, current, and next journal article
2481            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2482            * @throws SystemException if a system exception occurred
2483            */
2484            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext(
2485                    long id, long groupId, long userId,
2486                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2487                    throws com.liferay.portal.kernel.exception.SystemException,
2488                            com.liferay.portlet.journal.NoSuchArticleException {
2489                    return getPersistence()
2490                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2491                            orderByComparator);
2492            }
2493    
2494            /**
2495            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2496            *
2497            * @param groupId the group ID
2498            * @param userId the user ID
2499            * @throws SystemException if a system exception occurred
2500            */
2501            public static void removeByG_U(long groupId, long userId)
2502                    throws com.liferay.portal.kernel.exception.SystemException {
2503                    getPersistence().removeByG_U(groupId, userId);
2504            }
2505    
2506            /**
2507            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2508            *
2509            * @param groupId the group ID
2510            * @param userId the user ID
2511            * @return the number of matching journal articles
2512            * @throws SystemException if a system exception occurred
2513            */
2514            public static int countByG_U(long groupId, long userId)
2515                    throws com.liferay.portal.kernel.exception.SystemException {
2516                    return getPersistence().countByG_U(groupId, userId);
2517            }
2518    
2519            /**
2520            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2521            *
2522            * @param groupId the group ID
2523            * @param userId the user ID
2524            * @return the number of matching journal articles that the user has permission to view
2525            * @throws SystemException if a system exception occurred
2526            */
2527            public static int filterCountByG_U(long groupId, long userId)
2528                    throws com.liferay.portal.kernel.exception.SystemException {
2529                    return getPersistence().filterCountByG_U(groupId, userId);
2530            }
2531    
2532            /**
2533            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2534            *
2535            * @param groupId the group ID
2536            * @param folderId the folder ID
2537            * @return the matching journal articles
2538            * @throws SystemException if a system exception occurred
2539            */
2540            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2541                    long groupId, long folderId)
2542                    throws com.liferay.portal.kernel.exception.SystemException {
2543                    return getPersistence().findByG_F(groupId, folderId);
2544            }
2545    
2546            /**
2547            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2548            *
2549            * <p>
2550            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2551            * </p>
2552            *
2553            * @param groupId the group ID
2554            * @param folderId the folder ID
2555            * @param start the lower bound of the range of journal articles
2556            * @param end the upper bound of the range of journal articles (not inclusive)
2557            * @return the range of matching journal articles
2558            * @throws SystemException if a system exception occurred
2559            */
2560            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2561                    long groupId, long folderId, int start, int end)
2562                    throws com.liferay.portal.kernel.exception.SystemException {
2563                    return getPersistence().findByG_F(groupId, folderId, start, end);
2564            }
2565    
2566            /**
2567            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2568            *
2569            * <p>
2570            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2571            * </p>
2572            *
2573            * @param groupId the group ID
2574            * @param folderId the folder ID
2575            * @param start the lower bound of the range of journal articles
2576            * @param end the upper bound of the range of journal articles (not inclusive)
2577            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2578            * @return the ordered range of matching journal articles
2579            * @throws SystemException if a system exception occurred
2580            */
2581            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2582                    long groupId, long folderId, int start, int end,
2583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2584                    throws com.liferay.portal.kernel.exception.SystemException {
2585                    return getPersistence()
2586                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2587            }
2588    
2589            /**
2590            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2591            *
2592            * @param groupId the group ID
2593            * @param folderId the folder ID
2594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2595            * @return the first matching journal article
2596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2597            * @throws SystemException if a system exception occurred
2598            */
2599            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First(
2600                    long groupId, long folderId,
2601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2602                    throws com.liferay.portal.kernel.exception.SystemException,
2603                            com.liferay.portlet.journal.NoSuchArticleException {
2604                    return getPersistence()
2605                                       .findByG_F_First(groupId, folderId, orderByComparator);
2606            }
2607    
2608            /**
2609            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2610            *
2611            * @param groupId the group ID
2612            * @param folderId the folder ID
2613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2614            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2615            * @throws SystemException if a system exception occurred
2616            */
2617            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First(
2618                    long groupId, long folderId,
2619                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2620                    throws com.liferay.portal.kernel.exception.SystemException {
2621                    return getPersistence()
2622                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2623            }
2624    
2625            /**
2626            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2627            *
2628            * @param groupId the group ID
2629            * @param folderId the folder ID
2630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2631            * @return the last matching journal article
2632            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2633            * @throws SystemException if a system exception occurred
2634            */
2635            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last(
2636                    long groupId, long folderId,
2637                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2638                    throws com.liferay.portal.kernel.exception.SystemException,
2639                            com.liferay.portlet.journal.NoSuchArticleException {
2640                    return getPersistence()
2641                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2642            }
2643    
2644            /**
2645            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2646            *
2647            * @param groupId the group ID
2648            * @param folderId the folder ID
2649            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2650            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2651            * @throws SystemException if a system exception occurred
2652            */
2653            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last(
2654                    long groupId, long folderId,
2655                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2656                    throws com.liferay.portal.kernel.exception.SystemException {
2657                    return getPersistence()
2658                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2659            }
2660    
2661            /**
2662            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2663            *
2664            * @param id the primary key of the current journal article
2665            * @param groupId the group ID
2666            * @param folderId the folder ID
2667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2668            * @return the previous, current, and next journal article
2669            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2670            * @throws SystemException if a system exception occurred
2671            */
2672            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext(
2673                    long id, long groupId, long folderId,
2674                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2675                    throws com.liferay.portal.kernel.exception.SystemException,
2676                            com.liferay.portlet.journal.NoSuchArticleException {
2677                    return getPersistence()
2678                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2679                            orderByComparator);
2680            }
2681    
2682            /**
2683            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2684            *
2685            * @param groupId the group ID
2686            * @param folderId the folder ID
2687            * @return the matching journal articles that the user has permission to view
2688            * @throws SystemException if a system exception occurred
2689            */
2690            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2691                    long groupId, long folderId)
2692                    throws com.liferay.portal.kernel.exception.SystemException {
2693                    return getPersistence().filterFindByG_F(groupId, folderId);
2694            }
2695    
2696            /**
2697            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2698            *
2699            * <p>
2700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2701            * </p>
2702            *
2703            * @param groupId the group ID
2704            * @param folderId the folder ID
2705            * @param start the lower bound of the range of journal articles
2706            * @param end the upper bound of the range of journal articles (not inclusive)
2707            * @return the range of matching journal articles that the user has permission to view
2708            * @throws SystemException if a system exception occurred
2709            */
2710            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2711                    long groupId, long folderId, int start, int end)
2712                    throws com.liferay.portal.kernel.exception.SystemException {
2713                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2714            }
2715    
2716            /**
2717            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2718            *
2719            * <p>
2720            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2721            * </p>
2722            *
2723            * @param groupId the group ID
2724            * @param folderId the folder ID
2725            * @param start the lower bound of the range of journal articles
2726            * @param end the upper bound of the range of journal articles (not inclusive)
2727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2728            * @return the ordered range of matching journal articles that the user has permission to view
2729            * @throws SystemException if a system exception occurred
2730            */
2731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2732                    long groupId, long folderId, int start, int end,
2733                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2734                    throws com.liferay.portal.kernel.exception.SystemException {
2735                    return getPersistence()
2736                                       .filterFindByG_F(groupId, folderId, start, end,
2737                            orderByComparator);
2738            }
2739    
2740            /**
2741            * 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;.
2742            *
2743            * @param id the primary key of the current journal article
2744            * @param groupId the group ID
2745            * @param folderId the folder ID
2746            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2747            * @return the previous, current, and next journal article
2748            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2749            * @throws SystemException if a system exception occurred
2750            */
2751            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext(
2752                    long id, long groupId, long folderId,
2753                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2754                    throws com.liferay.portal.kernel.exception.SystemException,
2755                            com.liferay.portlet.journal.NoSuchArticleException {
2756                    return getPersistence()
2757                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2758                            orderByComparator);
2759            }
2760    
2761            /**
2762            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2763            *
2764            * @param groupId the group ID
2765            * @param folderIds the folder IDs
2766            * @return the matching journal articles that the user has permission to view
2767            * @throws SystemException if a system exception occurred
2768            */
2769            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2770                    long groupId, long[] folderIds)
2771                    throws com.liferay.portal.kernel.exception.SystemException {
2772                    return getPersistence().filterFindByG_F(groupId, folderIds);
2773            }
2774    
2775            /**
2776            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2777            *
2778            * <p>
2779            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2780            * </p>
2781            *
2782            * @param groupId the group ID
2783            * @param folderIds the folder IDs
2784            * @param start the lower bound of the range of journal articles
2785            * @param end the upper bound of the range of journal articles (not inclusive)
2786            * @return the range of matching journal articles that the user has permission to view
2787            * @throws SystemException if a system exception occurred
2788            */
2789            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2790                    long groupId, long[] folderIds, int start, int end)
2791                    throws com.liferay.portal.kernel.exception.SystemException {
2792                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2793            }
2794    
2795            /**
2796            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2797            *
2798            * <p>
2799            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2800            * </p>
2801            *
2802            * @param groupId the group ID
2803            * @param folderIds the folder IDs
2804            * @param start the lower bound of the range of journal articles
2805            * @param end the upper bound of the range of journal articles (not inclusive)
2806            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2807            * @return the ordered range of matching journal articles that the user has permission to view
2808            * @throws SystemException if a system exception occurred
2809            */
2810            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2811                    long groupId, long[] folderIds, int start, int end,
2812                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2813                    throws com.liferay.portal.kernel.exception.SystemException {
2814                    return getPersistence()
2815                                       .filterFindByG_F(groupId, folderIds, start, end,
2816                            orderByComparator);
2817            }
2818    
2819            /**
2820            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2821            *
2822            * <p>
2823            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2824            * </p>
2825            *
2826            * @param groupId the group ID
2827            * @param folderIds the folder IDs
2828            * @return the matching journal articles
2829            * @throws SystemException if a system exception occurred
2830            */
2831            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2832                    long groupId, long[] folderIds)
2833                    throws com.liferay.portal.kernel.exception.SystemException {
2834                    return getPersistence().findByG_F(groupId, folderIds);
2835            }
2836    
2837            /**
2838            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2839            *
2840            * <p>
2841            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2842            * </p>
2843            *
2844            * @param groupId the group ID
2845            * @param folderIds the folder IDs
2846            * @param start the lower bound of the range of journal articles
2847            * @param end the upper bound of the range of journal articles (not inclusive)
2848            * @return the range of matching journal articles
2849            * @throws SystemException if a system exception occurred
2850            */
2851            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2852                    long groupId, long[] folderIds, int start, int end)
2853                    throws com.liferay.portal.kernel.exception.SystemException {
2854                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2855            }
2856    
2857            /**
2858            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2859            *
2860            * <p>
2861            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2862            * </p>
2863            *
2864            * @param groupId the group ID
2865            * @param folderIds the folder IDs
2866            * @param start the lower bound of the range of journal articles
2867            * @param end the upper bound of the range of journal articles (not inclusive)
2868            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2869            * @return the ordered range of matching journal articles
2870            * @throws SystemException if a system exception occurred
2871            */
2872            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2873                    long groupId, long[] folderIds, int start, int end,
2874                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2875                    throws com.liferay.portal.kernel.exception.SystemException {
2876                    return getPersistence()
2877                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2878            }
2879    
2880            /**
2881            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2882            *
2883            * @param groupId the group ID
2884            * @param folderId the folder ID
2885            * @throws SystemException if a system exception occurred
2886            */
2887            public static void removeByG_F(long groupId, long folderId)
2888                    throws com.liferay.portal.kernel.exception.SystemException {
2889                    getPersistence().removeByG_F(groupId, folderId);
2890            }
2891    
2892            /**
2893            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2894            *
2895            * @param groupId the group ID
2896            * @param folderId the folder ID
2897            * @return the number of matching journal articles
2898            * @throws SystemException if a system exception occurred
2899            */
2900            public static int countByG_F(long groupId, long folderId)
2901                    throws com.liferay.portal.kernel.exception.SystemException {
2902                    return getPersistence().countByG_F(groupId, folderId);
2903            }
2904    
2905            /**
2906            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2907            *
2908            * @param groupId the group ID
2909            * @param folderIds the folder IDs
2910            * @return the number of matching journal articles
2911            * @throws SystemException if a system exception occurred
2912            */
2913            public static int countByG_F(long groupId, long[] folderIds)
2914                    throws com.liferay.portal.kernel.exception.SystemException {
2915                    return getPersistence().countByG_F(groupId, folderIds);
2916            }
2917    
2918            /**
2919            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2920            *
2921            * @param groupId the group ID
2922            * @param folderId the folder ID
2923            * @return the number of matching journal articles that the user has permission to view
2924            * @throws SystemException if a system exception occurred
2925            */
2926            public static int filterCountByG_F(long groupId, long folderId)
2927                    throws com.liferay.portal.kernel.exception.SystemException {
2928                    return getPersistence().filterCountByG_F(groupId, folderId);
2929            }
2930    
2931            /**
2932            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2933            *
2934            * @param groupId the group ID
2935            * @param folderIds the folder IDs
2936            * @return the number of matching journal articles that the user has permission to view
2937            * @throws SystemException if a system exception occurred
2938            */
2939            public static int filterCountByG_F(long groupId, long[] folderIds)
2940                    throws com.liferay.portal.kernel.exception.SystemException {
2941                    return getPersistence().filterCountByG_F(groupId, folderIds);
2942            }
2943    
2944            /**
2945            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2946            *
2947            * @param groupId the group ID
2948            * @param articleId the article ID
2949            * @return the matching journal articles
2950            * @throws SystemException if a system exception occurred
2951            */
2952            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2953                    long groupId, java.lang.String articleId)
2954                    throws com.liferay.portal.kernel.exception.SystemException {
2955                    return getPersistence().findByG_A(groupId, articleId);
2956            }
2957    
2958            /**
2959            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2960            *
2961            * <p>
2962            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2963            * </p>
2964            *
2965            * @param groupId the group ID
2966            * @param articleId the article ID
2967            * @param start the lower bound of the range of journal articles
2968            * @param end the upper bound of the range of journal articles (not inclusive)
2969            * @return the range of matching journal articles
2970            * @throws SystemException if a system exception occurred
2971            */
2972            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2973                    long groupId, java.lang.String articleId, int start, int end)
2974                    throws com.liferay.portal.kernel.exception.SystemException {
2975                    return getPersistence().findByG_A(groupId, articleId, start, end);
2976            }
2977    
2978            /**
2979            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2980            *
2981            * <p>
2982            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2983            * </p>
2984            *
2985            * @param groupId the group ID
2986            * @param articleId the article ID
2987            * @param start the lower bound of the range of journal articles
2988            * @param end the upper bound of the range of journal articles (not inclusive)
2989            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2990            * @return the ordered range of matching journal articles
2991            * @throws SystemException if a system exception occurred
2992            */
2993            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2994                    long groupId, java.lang.String articleId, int start, int end,
2995                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2996                    throws com.liferay.portal.kernel.exception.SystemException {
2997                    return getPersistence()
2998                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2999            }
3000    
3001            /**
3002            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3003            *
3004            * @param groupId the group ID
3005            * @param articleId the article ID
3006            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3007            * @return the first matching journal article
3008            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3009            * @throws SystemException if a system exception occurred
3010            */
3011            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
3012                    long groupId, java.lang.String articleId,
3013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3014                    throws com.liferay.portal.kernel.exception.SystemException,
3015                            com.liferay.portlet.journal.NoSuchArticleException {
3016                    return getPersistence()
3017                                       .findByG_A_First(groupId, articleId, orderByComparator);
3018            }
3019    
3020            /**
3021            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3022            *
3023            * @param groupId the group ID
3024            * @param articleId the article ID
3025            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3026            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3027            * @throws SystemException if a system exception occurred
3028            */
3029            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First(
3030                    long groupId, java.lang.String articleId,
3031                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3032                    throws com.liferay.portal.kernel.exception.SystemException {
3033                    return getPersistence()
3034                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
3035            }
3036    
3037            /**
3038            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3039            *
3040            * @param groupId the group ID
3041            * @param articleId the article ID
3042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3043            * @return the last matching journal article
3044            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3045            * @throws SystemException if a system exception occurred
3046            */
3047            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
3048                    long groupId, java.lang.String articleId,
3049                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3050                    throws com.liferay.portal.kernel.exception.SystemException,
3051                            com.liferay.portlet.journal.NoSuchArticleException {
3052                    return getPersistence()
3053                                       .findByG_A_Last(groupId, articleId, orderByComparator);
3054            }
3055    
3056            /**
3057            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3058            *
3059            * @param groupId the group ID
3060            * @param articleId the article ID
3061            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3062            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3063            * @throws SystemException if a system exception occurred
3064            */
3065            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
3066                    long groupId, java.lang.String articleId,
3067                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3068                    throws com.liferay.portal.kernel.exception.SystemException {
3069                    return getPersistence()
3070                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
3071            }
3072    
3073            /**
3074            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3075            *
3076            * @param id the primary key of the current journal article
3077            * @param groupId the group ID
3078            * @param articleId the article ID
3079            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3080            * @return the previous, current, and next journal article
3081            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3082            * @throws SystemException if a system exception occurred
3083            */
3084            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
3085                    long id, long groupId, java.lang.String articleId,
3086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3087                    throws com.liferay.portal.kernel.exception.SystemException,
3088                            com.liferay.portlet.journal.NoSuchArticleException {
3089                    return getPersistence()
3090                                       .findByG_A_PrevAndNext(id, groupId, articleId,
3091                            orderByComparator);
3092            }
3093    
3094            /**
3095            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3096            *
3097            * @param groupId the group ID
3098            * @param articleId the article ID
3099            * @return the matching journal articles that the user has permission to view
3100            * @throws SystemException if a system exception occurred
3101            */
3102            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
3103                    long groupId, java.lang.String articleId)
3104                    throws com.liferay.portal.kernel.exception.SystemException {
3105                    return getPersistence().filterFindByG_A(groupId, articleId);
3106            }
3107    
3108            /**
3109            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3110            *
3111            * <p>
3112            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3113            * </p>
3114            *
3115            * @param groupId the group ID
3116            * @param articleId the article ID
3117            * @param start the lower bound of the range of journal articles
3118            * @param end the upper bound of the range of journal articles (not inclusive)
3119            * @return the range of matching journal articles that the user has permission to view
3120            * @throws SystemException if a system exception occurred
3121            */
3122            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
3123                    long groupId, java.lang.String articleId, int start, int end)
3124                    throws com.liferay.portal.kernel.exception.SystemException {
3125                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
3126            }
3127    
3128            /**
3129            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
3130            *
3131            * <p>
3132            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3133            * </p>
3134            *
3135            * @param groupId the group ID
3136            * @param articleId the article ID
3137            * @param start the lower bound of the range of journal articles
3138            * @param end the upper bound of the range of journal articles (not inclusive)
3139            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3140            * @return the ordered range of matching journal articles that the user has permission to view
3141            * @throws SystemException if a system exception occurred
3142            */
3143            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
3144                    long groupId, java.lang.String articleId, int start, int end,
3145                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3146                    throws com.liferay.portal.kernel.exception.SystemException {
3147                    return getPersistence()
3148                                       .filterFindByG_A(groupId, articleId, start, end,
3149                            orderByComparator);
3150            }
3151    
3152            /**
3153            * 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;.
3154            *
3155            * @param id the primary key of the current journal article
3156            * @param groupId the group ID
3157            * @param articleId the article ID
3158            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3159            * @return the previous, current, and next journal article
3160            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3161            * @throws SystemException if a system exception occurred
3162            */
3163            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
3164                    long id, long groupId, java.lang.String articleId,
3165                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3166                    throws com.liferay.portal.kernel.exception.SystemException,
3167                            com.liferay.portlet.journal.NoSuchArticleException {
3168                    return getPersistence()
3169                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
3170                            orderByComparator);
3171            }
3172    
3173            /**
3174            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
3175            *
3176            * @param groupId the group ID
3177            * @param articleId the article ID
3178            * @throws SystemException if a system exception occurred
3179            */
3180            public static void removeByG_A(long groupId, java.lang.String articleId)
3181                    throws com.liferay.portal.kernel.exception.SystemException {
3182                    getPersistence().removeByG_A(groupId, articleId);
3183            }
3184    
3185            /**
3186            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
3187            *
3188            * @param groupId the group ID
3189            * @param articleId the article ID
3190            * @return the number of matching journal articles
3191            * @throws SystemException if a system exception occurred
3192            */
3193            public static int countByG_A(long groupId, java.lang.String articleId)
3194                    throws com.liferay.portal.kernel.exception.SystemException {
3195                    return getPersistence().countByG_A(groupId, articleId);
3196            }
3197    
3198            /**
3199            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3200            *
3201            * @param groupId the group ID
3202            * @param articleId the article ID
3203            * @return the number of matching journal articles that the user has permission to view
3204            * @throws SystemException if a system exception occurred
3205            */
3206            public static int filterCountByG_A(long groupId, java.lang.String articleId)
3207                    throws com.liferay.portal.kernel.exception.SystemException {
3208                    return getPersistence().filterCountByG_A(groupId, articleId);
3209            }
3210    
3211            /**
3212            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
3213            *
3214            * @param groupId the group ID
3215            * @param urlTitle the url title
3216            * @return the matching journal articles
3217            * @throws SystemException if a system exception occurred
3218            */
3219            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3220                    long groupId, java.lang.String urlTitle)
3221                    throws com.liferay.portal.kernel.exception.SystemException {
3222                    return getPersistence().findByG_UT(groupId, urlTitle);
3223            }
3224    
3225            /**
3226            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
3227            *
3228            * <p>
3229            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3230            * </p>
3231            *
3232            * @param groupId the group ID
3233            * @param urlTitle the url title
3234            * @param start the lower bound of the range of journal articles
3235            * @param end the upper bound of the range of journal articles (not inclusive)
3236            * @return the range of matching journal articles
3237            * @throws SystemException if a system exception occurred
3238            */
3239            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3240                    long groupId, java.lang.String urlTitle, int start, int end)
3241                    throws com.liferay.portal.kernel.exception.SystemException {
3242                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
3243            }
3244    
3245            /**
3246            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
3247            *
3248            * <p>
3249            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3250            * </p>
3251            *
3252            * @param groupId the group ID
3253            * @param urlTitle the url title
3254            * @param start the lower bound of the range of journal articles
3255            * @param end the upper bound of the range of journal articles (not inclusive)
3256            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3257            * @return the ordered range of matching journal articles
3258            * @throws SystemException if a system exception occurred
3259            */
3260            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3261                    long groupId, java.lang.String urlTitle, int start, int end,
3262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3263                    throws com.liferay.portal.kernel.exception.SystemException {
3264                    return getPersistence()
3265                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
3266            }
3267    
3268            /**
3269            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3270            *
3271            * @param groupId the group ID
3272            * @param urlTitle the url title
3273            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3274            * @return the first matching journal article
3275            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3276            * @throws SystemException if a system exception occurred
3277            */
3278            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
3279                    long groupId, java.lang.String urlTitle,
3280                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3281                    throws com.liferay.portal.kernel.exception.SystemException,
3282                            com.liferay.portlet.journal.NoSuchArticleException {
3283                    return getPersistence()
3284                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
3285            }
3286    
3287            /**
3288            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3289            *
3290            * @param groupId the group ID
3291            * @param urlTitle the url title
3292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3293            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3294            * @throws SystemException if a system exception occurred
3295            */
3296            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
3297                    long groupId, java.lang.String urlTitle,
3298                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3299                    throws com.liferay.portal.kernel.exception.SystemException {
3300                    return getPersistence()
3301                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
3302            }
3303    
3304            /**
3305            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3306            *
3307            * @param groupId the group ID
3308            * @param urlTitle the url title
3309            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3310            * @return the last matching journal article
3311            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3312            * @throws SystemException if a system exception occurred
3313            */
3314            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
3315                    long groupId, java.lang.String urlTitle,
3316                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3317                    throws com.liferay.portal.kernel.exception.SystemException,
3318                            com.liferay.portlet.journal.NoSuchArticleException {
3319                    return getPersistence()
3320                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
3321            }
3322    
3323            /**
3324            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3325            *
3326            * @param groupId the group ID
3327            * @param urlTitle the url title
3328            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3329            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3330            * @throws SystemException if a system exception occurred
3331            */
3332            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
3333                    long groupId, java.lang.String urlTitle,
3334                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3335                    throws com.liferay.portal.kernel.exception.SystemException {
3336                    return getPersistence()
3337                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
3338            }
3339    
3340            /**
3341            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3342            *
3343            * @param id the primary key of the current journal article
3344            * @param groupId the group ID
3345            * @param urlTitle the url title
3346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3347            * @return the previous, current, and next journal article
3348            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3349            * @throws SystemException if a system exception occurred
3350            */
3351            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
3352                    long id, long groupId, java.lang.String urlTitle,
3353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3354                    throws com.liferay.portal.kernel.exception.SystemException,
3355                            com.liferay.portlet.journal.NoSuchArticleException {
3356                    return getPersistence()
3357                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
3358                            orderByComparator);
3359            }
3360    
3361            /**
3362            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3363            *
3364            * @param groupId the group ID
3365            * @param urlTitle the url title
3366            * @return the matching journal articles that the user has permission to view
3367            * @throws SystemException if a system exception occurred
3368            */
3369            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3370                    long groupId, java.lang.String urlTitle)
3371                    throws com.liferay.portal.kernel.exception.SystemException {
3372                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
3373            }
3374    
3375            /**
3376            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3377            *
3378            * <p>
3379            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3380            * </p>
3381            *
3382            * @param groupId the group ID
3383            * @param urlTitle the url title
3384            * @param start the lower bound of the range of journal articles
3385            * @param end the upper bound of the range of journal articles (not inclusive)
3386            * @return the range of matching journal articles that the user has permission to view
3387            * @throws SystemException if a system exception occurred
3388            */
3389            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3390                    long groupId, java.lang.String urlTitle, int start, int end)
3391                    throws com.liferay.portal.kernel.exception.SystemException {
3392                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
3393            }
3394    
3395            /**
3396            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
3397            *
3398            * <p>
3399            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3400            * </p>
3401            *
3402            * @param groupId the group ID
3403            * @param urlTitle the url title
3404            * @param start the lower bound of the range of journal articles
3405            * @param end the upper bound of the range of journal articles (not inclusive)
3406            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3407            * @return the ordered range of matching journal articles that the user has permission to view
3408            * @throws SystemException if a system exception occurred
3409            */
3410            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3411                    long groupId, java.lang.String urlTitle, int start, int end,
3412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3413                    throws com.liferay.portal.kernel.exception.SystemException {
3414                    return getPersistence()
3415                                       .filterFindByG_UT(groupId, urlTitle, start, end,
3416                            orderByComparator);
3417            }
3418    
3419            /**
3420            * 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;.
3421            *
3422            * @param id the primary key of the current journal article
3423            * @param groupId the group ID
3424            * @param urlTitle the url title
3425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3426            * @return the previous, current, and next journal article
3427            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3428            * @throws SystemException if a system exception occurred
3429            */
3430            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
3431                    long id, long groupId, java.lang.String urlTitle,
3432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3433                    throws com.liferay.portal.kernel.exception.SystemException,
3434                            com.liferay.portlet.journal.NoSuchArticleException {
3435                    return getPersistence()
3436                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
3437                            orderByComparator);
3438            }
3439    
3440            /**
3441            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3442            *
3443            * @param groupId the group ID
3444            * @param urlTitle the url title
3445            * @throws SystemException if a system exception occurred
3446            */
3447            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
3448                    throws com.liferay.portal.kernel.exception.SystemException {
3449                    getPersistence().removeByG_UT(groupId, urlTitle);
3450            }
3451    
3452            /**
3453            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3454            *
3455            * @param groupId the group ID
3456            * @param urlTitle the url title
3457            * @return the number of matching journal articles
3458            * @throws SystemException if a system exception occurred
3459            */
3460            public static int countByG_UT(long groupId, java.lang.String urlTitle)
3461                    throws com.liferay.portal.kernel.exception.SystemException {
3462                    return getPersistence().countByG_UT(groupId, urlTitle);
3463            }
3464    
3465            /**
3466            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3467            *
3468            * @param groupId the group ID
3469            * @param urlTitle the url title
3470            * @return the number of matching journal articles that the user has permission to view
3471            * @throws SystemException if a system exception occurred
3472            */
3473            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
3474                    throws com.liferay.portal.kernel.exception.SystemException {
3475                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3476            }
3477    
3478            /**
3479            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
3480            *
3481            * @param groupId the group ID
3482            * @param structureId the structure ID
3483            * @return the matching journal articles
3484            * @throws SystemException if a system exception occurred
3485            */
3486            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3487                    long groupId, java.lang.String structureId)
3488                    throws com.liferay.portal.kernel.exception.SystemException {
3489                    return getPersistence().findByG_S(groupId, structureId);
3490            }
3491    
3492            /**
3493            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
3494            *
3495            * <p>
3496            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3497            * </p>
3498            *
3499            * @param groupId the group ID
3500            * @param structureId the structure ID
3501            * @param start the lower bound of the range of journal articles
3502            * @param end the upper bound of the range of journal articles (not inclusive)
3503            * @return the range of matching journal articles
3504            * @throws SystemException if a system exception occurred
3505            */
3506            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3507                    long groupId, java.lang.String structureId, int start, int end)
3508                    throws com.liferay.portal.kernel.exception.SystemException {
3509                    return getPersistence().findByG_S(groupId, structureId, start, end);
3510            }
3511    
3512            /**
3513            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
3514            *
3515            * <p>
3516            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3517            * </p>
3518            *
3519            * @param groupId the group ID
3520            * @param structureId the structure ID
3521            * @param start the lower bound of the range of journal articles
3522            * @param end the upper bound of the range of journal articles (not inclusive)
3523            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3524            * @return the ordered range of matching journal articles
3525            * @throws SystemException if a system exception occurred
3526            */
3527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3528                    long groupId, java.lang.String structureId, int start, int end,
3529                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3530                    throws com.liferay.portal.kernel.exception.SystemException {
3531                    return getPersistence()
3532                                       .findByG_S(groupId, structureId, start, end,
3533                            orderByComparator);
3534            }
3535    
3536            /**
3537            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3538            *
3539            * @param groupId the group ID
3540            * @param structureId the structure ID
3541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3542            * @return the first matching journal article
3543            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3544            * @throws SystemException if a system exception occurred
3545            */
3546            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
3547                    long groupId, java.lang.String structureId,
3548                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3549                    throws com.liferay.portal.kernel.exception.SystemException,
3550                            com.liferay.portlet.journal.NoSuchArticleException {
3551                    return getPersistence()
3552                                       .findByG_S_First(groupId, structureId, orderByComparator);
3553            }
3554    
3555            /**
3556            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3557            *
3558            * @param groupId the group ID
3559            * @param structureId the structure ID
3560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3561            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3562            * @throws SystemException if a system exception occurred
3563            */
3564            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
3565                    long groupId, java.lang.String structureId,
3566                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3567                    throws com.liferay.portal.kernel.exception.SystemException {
3568                    return getPersistence()
3569                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
3570            }
3571    
3572            /**
3573            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3574            *
3575            * @param groupId the group ID
3576            * @param structureId the structure ID
3577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3578            * @return the last matching journal article
3579            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3580            * @throws SystemException if a system exception occurred
3581            */
3582            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
3583                    long groupId, java.lang.String structureId,
3584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3585                    throws com.liferay.portal.kernel.exception.SystemException,
3586                            com.liferay.portlet.journal.NoSuchArticleException {
3587                    return getPersistence()
3588                                       .findByG_S_Last(groupId, structureId, orderByComparator);
3589            }
3590    
3591            /**
3592            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3593            *
3594            * @param groupId the group ID
3595            * @param structureId the structure ID
3596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3597            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3598            * @throws SystemException if a system exception occurred
3599            */
3600            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
3601                    long groupId, java.lang.String structureId,
3602                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3603                    throws com.liferay.portal.kernel.exception.SystemException {
3604                    return getPersistence()
3605                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
3606            }
3607    
3608            /**
3609            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3610            *
3611            * @param id the primary key of the current journal article
3612            * @param groupId the group ID
3613            * @param structureId the structure ID
3614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3615            * @return the previous, current, and next journal article
3616            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3617            * @throws SystemException if a system exception occurred
3618            */
3619            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
3620                    long id, long groupId, java.lang.String structureId,
3621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3622                    throws com.liferay.portal.kernel.exception.SystemException,
3623                            com.liferay.portlet.journal.NoSuchArticleException {
3624                    return getPersistence()
3625                                       .findByG_S_PrevAndNext(id, groupId, structureId,
3626                            orderByComparator);
3627            }
3628    
3629            /**
3630            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3631            *
3632            * @param groupId the group ID
3633            * @param structureId the structure ID
3634            * @return the matching journal articles that the user has permission to view
3635            * @throws SystemException if a system exception occurred
3636            */
3637            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3638                    long groupId, java.lang.String structureId)
3639                    throws com.liferay.portal.kernel.exception.SystemException {
3640                    return getPersistence().filterFindByG_S(groupId, structureId);
3641            }
3642    
3643            /**
3644            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3645            *
3646            * <p>
3647            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3648            * </p>
3649            *
3650            * @param groupId the group ID
3651            * @param structureId the structure ID
3652            * @param start the lower bound of the range of journal articles
3653            * @param end the upper bound of the range of journal articles (not inclusive)
3654            * @return the range of matching journal articles that the user has permission to view
3655            * @throws SystemException if a system exception occurred
3656            */
3657            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3658                    long groupId, java.lang.String structureId, int start, int end)
3659                    throws com.liferay.portal.kernel.exception.SystemException {
3660                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
3661            }
3662    
3663            /**
3664            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
3665            *
3666            * <p>
3667            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3668            * </p>
3669            *
3670            * @param groupId the group ID
3671            * @param structureId the structure ID
3672            * @param start the lower bound of the range of journal articles
3673            * @param end the upper bound of the range of journal articles (not inclusive)
3674            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3675            * @return the ordered range of matching journal articles that the user has permission to view
3676            * @throws SystemException if a system exception occurred
3677            */
3678            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3679                    long groupId, java.lang.String structureId, int start, int end,
3680                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3681                    throws com.liferay.portal.kernel.exception.SystemException {
3682                    return getPersistence()
3683                                       .filterFindByG_S(groupId, structureId, start, end,
3684                            orderByComparator);
3685            }
3686    
3687            /**
3688            * 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;.
3689            *
3690            * @param id the primary key of the current journal article
3691            * @param groupId the group ID
3692            * @param structureId the structure ID
3693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3694            * @return the previous, current, and next journal article
3695            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3696            * @throws SystemException if a system exception occurred
3697            */
3698            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
3699                    long id, long groupId, java.lang.String structureId,
3700                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3701                    throws com.liferay.portal.kernel.exception.SystemException,
3702                            com.liferay.portlet.journal.NoSuchArticleException {
3703                    return getPersistence()
3704                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
3705                            orderByComparator);
3706            }
3707    
3708            /**
3709            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
3710            *
3711            * @param groupId the group ID
3712            * @param structureId the structure ID
3713            * @throws SystemException if a system exception occurred
3714            */
3715            public static void removeByG_S(long groupId, java.lang.String structureId)
3716                    throws com.liferay.portal.kernel.exception.SystemException {
3717                    getPersistence().removeByG_S(groupId, structureId);
3718            }
3719    
3720            /**
3721            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
3722            *
3723            * @param groupId the group ID
3724            * @param structureId the structure ID
3725            * @return the number of matching journal articles
3726            * @throws SystemException if a system exception occurred
3727            */
3728            public static int countByG_S(long groupId, java.lang.String structureId)
3729                    throws com.liferay.portal.kernel.exception.SystemException {
3730                    return getPersistence().countByG_S(groupId, structureId);
3731            }
3732    
3733            /**
3734            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3735            *
3736            * @param groupId the group ID
3737            * @param structureId the structure ID
3738            * @return the number of matching journal articles that the user has permission to view
3739            * @throws SystemException if a system exception occurred
3740            */
3741            public static int filterCountByG_S(long groupId,
3742                    java.lang.String structureId)
3743                    throws com.liferay.portal.kernel.exception.SystemException {
3744                    return getPersistence().filterCountByG_S(groupId, structureId);
3745            }
3746    
3747            /**
3748            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
3749            *
3750            * @param groupId the group ID
3751            * @param templateId the template ID
3752            * @return the matching journal articles
3753            * @throws SystemException if a system exception occurred
3754            */
3755            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3756                    long groupId, java.lang.String templateId)
3757                    throws com.liferay.portal.kernel.exception.SystemException {
3758                    return getPersistence().findByG_T(groupId, templateId);
3759            }
3760    
3761            /**
3762            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
3763            *
3764            * <p>
3765            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3766            * </p>
3767            *
3768            * @param groupId the group ID
3769            * @param templateId the template ID
3770            * @param start the lower bound of the range of journal articles
3771            * @param end the upper bound of the range of journal articles (not inclusive)
3772            * @return the range of matching journal articles
3773            * @throws SystemException if a system exception occurred
3774            */
3775            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3776                    long groupId, java.lang.String templateId, int start, int end)
3777                    throws com.liferay.portal.kernel.exception.SystemException {
3778                    return getPersistence().findByG_T(groupId, templateId, start, end);
3779            }
3780    
3781            /**
3782            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
3783            *
3784            * <p>
3785            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3786            * </p>
3787            *
3788            * @param groupId the group ID
3789            * @param templateId the template ID
3790            * @param start the lower bound of the range of journal articles
3791            * @param end the upper bound of the range of journal articles (not inclusive)
3792            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3793            * @return the ordered range of matching journal articles
3794            * @throws SystemException if a system exception occurred
3795            */
3796            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3797                    long groupId, java.lang.String templateId, int start, int end,
3798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3799                    throws com.liferay.portal.kernel.exception.SystemException {
3800                    return getPersistence()
3801                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
3802            }
3803    
3804            /**
3805            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3806            *
3807            * @param groupId the group ID
3808            * @param templateId the template ID
3809            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3810            * @return the first matching journal article
3811            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3812            * @throws SystemException if a system exception occurred
3813            */
3814            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
3815                    long groupId, java.lang.String templateId,
3816                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3817                    throws com.liferay.portal.kernel.exception.SystemException,
3818                            com.liferay.portlet.journal.NoSuchArticleException {
3819                    return getPersistence()
3820                                       .findByG_T_First(groupId, templateId, orderByComparator);
3821            }
3822    
3823            /**
3824            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3825            *
3826            * @param groupId the group ID
3827            * @param templateId the template ID
3828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3829            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3830            * @throws SystemException if a system exception occurred
3831            */
3832            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
3833                    long groupId, java.lang.String templateId,
3834                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3835                    throws com.liferay.portal.kernel.exception.SystemException {
3836                    return getPersistence()
3837                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
3838            }
3839    
3840            /**
3841            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3842            *
3843            * @param groupId the group ID
3844            * @param templateId the template ID
3845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3846            * @return the last matching journal article
3847            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3848            * @throws SystemException if a system exception occurred
3849            */
3850            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
3851                    long groupId, java.lang.String templateId,
3852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3853                    throws com.liferay.portal.kernel.exception.SystemException,
3854                            com.liferay.portlet.journal.NoSuchArticleException {
3855                    return getPersistence()
3856                                       .findByG_T_Last(groupId, templateId, orderByComparator);
3857            }
3858    
3859            /**
3860            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3861            *
3862            * @param groupId the group ID
3863            * @param templateId the template ID
3864            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3865            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3866            * @throws SystemException if a system exception occurred
3867            */
3868            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last(
3869                    long groupId, java.lang.String templateId,
3870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3871                    throws com.liferay.portal.kernel.exception.SystemException {
3872                    return getPersistence()
3873                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
3874            }
3875    
3876            /**
3877            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3878            *
3879            * @param id the primary key of the current journal article
3880            * @param groupId the group ID
3881            * @param templateId the template ID
3882            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3883            * @return the previous, current, and next journal article
3884            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3885            * @throws SystemException if a system exception occurred
3886            */
3887            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
3888                    long id, long groupId, java.lang.String templateId,
3889                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3890                    throws com.liferay.portal.kernel.exception.SystemException,
3891                            com.liferay.portlet.journal.NoSuchArticleException {
3892                    return getPersistence()
3893                                       .findByG_T_PrevAndNext(id, groupId, templateId,
3894                            orderByComparator);
3895            }
3896    
3897            /**
3898            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3899            *
3900            * @param groupId the group ID
3901            * @param templateId the template ID
3902            * @return the matching journal articles that the user has permission to view
3903            * @throws SystemException if a system exception occurred
3904            */
3905            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3906                    long groupId, java.lang.String templateId)
3907                    throws com.liferay.portal.kernel.exception.SystemException {
3908                    return getPersistence().filterFindByG_T(groupId, templateId);
3909            }
3910    
3911            /**
3912            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3913            *
3914            * <p>
3915            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3916            * </p>
3917            *
3918            * @param groupId the group ID
3919            * @param templateId the template ID
3920            * @param start the lower bound of the range of journal articles
3921            * @param end the upper bound of the range of journal articles (not inclusive)
3922            * @return the range of matching journal articles that the user has permission to view
3923            * @throws SystemException if a system exception occurred
3924            */
3925            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3926                    long groupId, java.lang.String templateId, int start, int end)
3927                    throws com.liferay.portal.kernel.exception.SystemException {
3928                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
3929            }
3930    
3931            /**
3932            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
3933            *
3934            * <p>
3935            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3936            * </p>
3937            *
3938            * @param groupId the group ID
3939            * @param templateId the template ID
3940            * @param start the lower bound of the range of journal articles
3941            * @param end the upper bound of the range of journal articles (not inclusive)
3942            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3943            * @return the ordered range of matching journal articles that the user has permission to view
3944            * @throws SystemException if a system exception occurred
3945            */
3946            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3947                    long groupId, java.lang.String templateId, int start, int end,
3948                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3949                    throws com.liferay.portal.kernel.exception.SystemException {
3950                    return getPersistence()
3951                                       .filterFindByG_T(groupId, templateId, start, end,
3952                            orderByComparator);
3953            }
3954    
3955            /**
3956            * 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;.
3957            *
3958            * @param id the primary key of the current journal article
3959            * @param groupId the group ID
3960            * @param templateId the template ID
3961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3962            * @return the previous, current, and next journal article
3963            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3964            * @throws SystemException if a system exception occurred
3965            */
3966            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
3967                    long id, long groupId, java.lang.String templateId,
3968                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3969                    throws com.liferay.portal.kernel.exception.SystemException,
3970                            com.liferay.portlet.journal.NoSuchArticleException {
3971                    return getPersistence()
3972                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
3973                            orderByComparator);
3974            }
3975    
3976            /**
3977            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
3978            *
3979            * @param groupId the group ID
3980            * @param templateId the template ID
3981            * @throws SystemException if a system exception occurred
3982            */
3983            public static void removeByG_T(long groupId, java.lang.String templateId)
3984                    throws com.liferay.portal.kernel.exception.SystemException {
3985                    getPersistence().removeByG_T(groupId, templateId);
3986            }
3987    
3988            /**
3989            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
3990            *
3991            * @param groupId the group ID
3992            * @param templateId the template ID
3993            * @return the number of matching journal articles
3994            * @throws SystemException if a system exception occurred
3995            */
3996            public static int countByG_T(long groupId, java.lang.String templateId)
3997                    throws com.liferay.portal.kernel.exception.SystemException {
3998                    return getPersistence().countByG_T(groupId, templateId);
3999            }
4000    
4001            /**
4002            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
4003            *
4004            * @param groupId the group ID
4005            * @param templateId the template ID
4006            * @return the number of matching journal articles that the user has permission to view
4007            * @throws SystemException if a system exception occurred
4008            */
4009            public static int filterCountByG_T(long groupId, java.lang.String templateId)
4010                    throws com.liferay.portal.kernel.exception.SystemException {
4011                    return getPersistence().filterCountByG_T(groupId, templateId);
4012            }
4013    
4014            /**
4015            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
4016            *
4017            * @param groupId the group ID
4018            * @param layoutUuid the layout uuid
4019            * @return the matching journal articles
4020            * @throws SystemException if a system exception occurred
4021            */
4022            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
4023                    long groupId, java.lang.String layoutUuid)
4024                    throws com.liferay.portal.kernel.exception.SystemException {
4025                    return getPersistence().findByG_L(groupId, layoutUuid);
4026            }
4027    
4028            /**
4029            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
4030            *
4031            * <p>
4032            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4033            * </p>
4034            *
4035            * @param groupId the group ID
4036            * @param layoutUuid the layout uuid
4037            * @param start the lower bound of the range of journal articles
4038            * @param end the upper bound of the range of journal articles (not inclusive)
4039            * @return the range of matching journal articles
4040            * @throws SystemException if a system exception occurred
4041            */
4042            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
4043                    long groupId, java.lang.String layoutUuid, int start, int end)
4044                    throws com.liferay.portal.kernel.exception.SystemException {
4045                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
4046            }
4047    
4048            /**
4049            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
4050            *
4051            * <p>
4052            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4053            * </p>
4054            *
4055            * @param groupId the group ID
4056            * @param layoutUuid the layout uuid
4057            * @param start the lower bound of the range of journal articles
4058            * @param end the upper bound of the range of journal articles (not inclusive)
4059            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4060            * @return the ordered range of matching journal articles
4061            * @throws SystemException if a system exception occurred
4062            */
4063            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
4064                    long groupId, java.lang.String layoutUuid, int start, int end,
4065                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4066                    throws com.liferay.portal.kernel.exception.SystemException {
4067                    return getPersistence()
4068                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
4069            }
4070    
4071            /**
4072            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4073            *
4074            * @param groupId the group ID
4075            * @param layoutUuid the layout uuid
4076            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4077            * @return the first matching journal article
4078            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4079            * @throws SystemException if a system exception occurred
4080            */
4081            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
4082                    long groupId, java.lang.String layoutUuid,
4083                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4084                    throws com.liferay.portal.kernel.exception.SystemException,
4085                            com.liferay.portlet.journal.NoSuchArticleException {
4086                    return getPersistence()
4087                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
4088            }
4089    
4090            /**
4091            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4092            *
4093            * @param groupId the group ID
4094            * @param layoutUuid the layout uuid
4095            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4096            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4097            * @throws SystemException if a system exception occurred
4098            */
4099            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
4100                    long groupId, java.lang.String layoutUuid,
4101                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4102                    throws com.liferay.portal.kernel.exception.SystemException {
4103                    return getPersistence()
4104                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
4105            }
4106    
4107            /**
4108            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4109            *
4110            * @param groupId the group ID
4111            * @param layoutUuid the layout uuid
4112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4113            * @return the last matching journal article
4114            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4115            * @throws SystemException if a system exception occurred
4116            */
4117            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
4118                    long groupId, java.lang.String layoutUuid,
4119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4120                    throws com.liferay.portal.kernel.exception.SystemException,
4121                            com.liferay.portlet.journal.NoSuchArticleException {
4122                    return getPersistence()
4123                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
4124            }
4125    
4126            /**
4127            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4128            *
4129            * @param groupId the group ID
4130            * @param layoutUuid the layout uuid
4131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4132            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4133            * @throws SystemException if a system exception occurred
4134            */
4135            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
4136                    long groupId, java.lang.String layoutUuid,
4137                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4138                    throws com.liferay.portal.kernel.exception.SystemException {
4139                    return getPersistence()
4140                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
4141            }
4142    
4143            /**
4144            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4145            *
4146            * @param id the primary key of the current journal article
4147            * @param groupId the group ID
4148            * @param layoutUuid the layout uuid
4149            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4150            * @return the previous, current, and next journal article
4151            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4152            * @throws SystemException if a system exception occurred
4153            */
4154            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
4155                    long id, long groupId, java.lang.String layoutUuid,
4156                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4157                    throws com.liferay.portal.kernel.exception.SystemException,
4158                            com.liferay.portlet.journal.NoSuchArticleException {
4159                    return getPersistence()
4160                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
4161                            orderByComparator);
4162            }
4163    
4164            /**
4165            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4166            *
4167            * @param groupId the group ID
4168            * @param layoutUuid the layout uuid
4169            * @return the matching journal articles that the user has permission to view
4170            * @throws SystemException if a system exception occurred
4171            */
4172            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
4173                    long groupId, java.lang.String layoutUuid)
4174                    throws com.liferay.portal.kernel.exception.SystemException {
4175                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
4176            }
4177    
4178            /**
4179            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4180            *
4181            * <p>
4182            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4183            * </p>
4184            *
4185            * @param groupId the group ID
4186            * @param layoutUuid the layout uuid
4187            * @param start the lower bound of the range of journal articles
4188            * @param end the upper bound of the range of journal articles (not inclusive)
4189            * @return the range of matching journal articles that the user has permission to view
4190            * @throws SystemException if a system exception occurred
4191            */
4192            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
4193                    long groupId, java.lang.String layoutUuid, int start, int end)
4194                    throws com.liferay.portal.kernel.exception.SystemException {
4195                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
4196            }
4197    
4198            /**
4199            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
4200            *
4201            * <p>
4202            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4203            * </p>
4204            *
4205            * @param groupId the group ID
4206            * @param layoutUuid the layout uuid
4207            * @param start the lower bound of the range of journal articles
4208            * @param end the upper bound of the range of journal articles (not inclusive)
4209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4210            * @return the ordered range of matching journal articles that the user has permission to view
4211            * @throws SystemException if a system exception occurred
4212            */
4213            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
4214                    long groupId, java.lang.String layoutUuid, int start, int end,
4215                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4216                    throws com.liferay.portal.kernel.exception.SystemException {
4217                    return getPersistence()
4218                                       .filterFindByG_L(groupId, layoutUuid, start, end,
4219                            orderByComparator);
4220            }
4221    
4222            /**
4223            * 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;.
4224            *
4225            * @param id the primary key of the current journal article
4226            * @param groupId the group ID
4227            * @param layoutUuid the layout uuid
4228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4229            * @return the previous, current, and next journal article
4230            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4231            * @throws SystemException if a system exception occurred
4232            */
4233            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
4234                    long id, long groupId, java.lang.String layoutUuid,
4235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4236                    throws com.liferay.portal.kernel.exception.SystemException,
4237                            com.liferay.portlet.journal.NoSuchArticleException {
4238                    return getPersistence()
4239                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
4240                            orderByComparator);
4241            }
4242    
4243            /**
4244            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
4245            *
4246            * @param groupId the group ID
4247            * @param layoutUuid the layout uuid
4248            * @throws SystemException if a system exception occurred
4249            */
4250            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
4251                    throws com.liferay.portal.kernel.exception.SystemException {
4252                    getPersistence().removeByG_L(groupId, layoutUuid);
4253            }
4254    
4255            /**
4256            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4257            *
4258            * @param groupId the group ID
4259            * @param layoutUuid the layout uuid
4260            * @return the number of matching journal articles
4261            * @throws SystemException if a system exception occurred
4262            */
4263            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4264                    throws com.liferay.portal.kernel.exception.SystemException {
4265                    return getPersistence().countByG_L(groupId, layoutUuid);
4266            }
4267    
4268            /**
4269            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4270            *
4271            * @param groupId the group ID
4272            * @param layoutUuid the layout uuid
4273            * @return the number of matching journal articles that the user has permission to view
4274            * @throws SystemException if a system exception occurred
4275            */
4276            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4277                    throws com.liferay.portal.kernel.exception.SystemException {
4278                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4279            }
4280    
4281            /**
4282            * Returns all the journal articles where groupId = &#63; and status = &#63;.
4283            *
4284            * @param groupId the group ID
4285            * @param status the status
4286            * @return the matching journal articles
4287            * @throws SystemException if a system exception occurred
4288            */
4289            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4290                    long groupId, int status)
4291                    throws com.liferay.portal.kernel.exception.SystemException {
4292                    return getPersistence().findByG_ST(groupId, status);
4293            }
4294    
4295            /**
4296            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
4297            *
4298            * <p>
4299            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4300            * </p>
4301            *
4302            * @param groupId the group ID
4303            * @param status the status
4304            * @param start the lower bound of the range of journal articles
4305            * @param end the upper bound of the range of journal articles (not inclusive)
4306            * @return the range of matching journal articles
4307            * @throws SystemException if a system exception occurred
4308            */
4309            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4310                    long groupId, int status, int start, int end)
4311                    throws com.liferay.portal.kernel.exception.SystemException {
4312                    return getPersistence().findByG_ST(groupId, status, start, end);
4313            }
4314    
4315            /**
4316            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
4317            *
4318            * <p>
4319            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4320            * </p>
4321            *
4322            * @param groupId the group ID
4323            * @param status the status
4324            * @param start the lower bound of the range of journal articles
4325            * @param end the upper bound of the range of journal articles (not inclusive)
4326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4327            * @return the ordered range of matching journal articles
4328            * @throws SystemException if a system exception occurred
4329            */
4330            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4331                    long groupId, int status, int start, int end,
4332                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4333                    throws com.liferay.portal.kernel.exception.SystemException {
4334                    return getPersistence()
4335                                       .findByG_ST(groupId, status, start, end, orderByComparator);
4336            }
4337    
4338            /**
4339            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4340            *
4341            * @param groupId the group ID
4342            * @param status the status
4343            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4344            * @return the first matching journal article
4345            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4346            * @throws SystemException if a system exception occurred
4347            */
4348            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
4349                    long groupId, int status,
4350                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4351                    throws com.liferay.portal.kernel.exception.SystemException,
4352                            com.liferay.portlet.journal.NoSuchArticleException {
4353                    return getPersistence()
4354                                       .findByG_ST_First(groupId, status, orderByComparator);
4355            }
4356    
4357            /**
4358            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4359            *
4360            * @param groupId the group ID
4361            * @param status the status
4362            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4363            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4364            * @throws SystemException if a system exception occurred
4365            */
4366            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
4367                    long groupId, int status,
4368                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4369                    throws com.liferay.portal.kernel.exception.SystemException {
4370                    return getPersistence()
4371                                       .fetchByG_ST_First(groupId, status, orderByComparator);
4372            }
4373    
4374            /**
4375            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4376            *
4377            * @param groupId the group ID
4378            * @param status the status
4379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4380            * @return the last matching journal article
4381            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4382            * @throws SystemException if a system exception occurred
4383            */
4384            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
4385                    long groupId, int status,
4386                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4387                    throws com.liferay.portal.kernel.exception.SystemException,
4388                            com.liferay.portlet.journal.NoSuchArticleException {
4389                    return getPersistence()
4390                                       .findByG_ST_Last(groupId, status, orderByComparator);
4391            }
4392    
4393            /**
4394            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4395            *
4396            * @param groupId the group ID
4397            * @param status the status
4398            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4399            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4400            * @throws SystemException if a system exception occurred
4401            */
4402            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last(
4403                    long groupId, int status,
4404                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4405                    throws com.liferay.portal.kernel.exception.SystemException {
4406                    return getPersistence()
4407                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
4408            }
4409    
4410            /**
4411            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
4412            *
4413            * @param id the primary key of the current journal article
4414            * @param groupId the group ID
4415            * @param status the status
4416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4417            * @return the previous, current, and next journal article
4418            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4419            * @throws SystemException if a system exception occurred
4420            */
4421            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
4422                    long id, long groupId, int status,
4423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4424                    throws com.liferay.portal.kernel.exception.SystemException,
4425                            com.liferay.portlet.journal.NoSuchArticleException {
4426                    return getPersistence()
4427                                       .findByG_ST_PrevAndNext(id, groupId, status,
4428                            orderByComparator);
4429            }
4430    
4431            /**
4432            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4433            *
4434            * @param groupId the group ID
4435            * @param status the status
4436            * @return the matching journal articles that the user has permission to view
4437            * @throws SystemException if a system exception occurred
4438            */
4439            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4440                    long groupId, int status)
4441                    throws com.liferay.portal.kernel.exception.SystemException {
4442                    return getPersistence().filterFindByG_ST(groupId, status);
4443            }
4444    
4445            /**
4446            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4447            *
4448            * <p>
4449            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4450            * </p>
4451            *
4452            * @param groupId the group ID
4453            * @param status the status
4454            * @param start the lower bound of the range of journal articles
4455            * @param end the upper bound of the range of journal articles (not inclusive)
4456            * @return the range of matching journal articles that the user has permission to view
4457            * @throws SystemException if a system exception occurred
4458            */
4459            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4460                    long groupId, int status, int start, int end)
4461                    throws com.liferay.portal.kernel.exception.SystemException {
4462                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
4463            }
4464    
4465            /**
4466            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
4467            *
4468            * <p>
4469            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4470            * </p>
4471            *
4472            * @param groupId the group ID
4473            * @param status the status
4474            * @param start the lower bound of the range of journal articles
4475            * @param end the upper bound of the range of journal articles (not inclusive)
4476            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4477            * @return the ordered range of matching journal articles that the user has permission to view
4478            * @throws SystemException if a system exception occurred
4479            */
4480            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4481                    long groupId, int status, int start, int end,
4482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4483                    throws com.liferay.portal.kernel.exception.SystemException {
4484                    return getPersistence()
4485                                       .filterFindByG_ST(groupId, status, start, end,
4486                            orderByComparator);
4487            }
4488    
4489            /**
4490            * 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;.
4491            *
4492            * @param id the primary key of the current journal article
4493            * @param groupId the group ID
4494            * @param status the status
4495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4496            * @return the previous, current, and next journal article
4497            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4498            * @throws SystemException if a system exception occurred
4499            */
4500            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
4501                    long id, long groupId, int status,
4502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4503                    throws com.liferay.portal.kernel.exception.SystemException,
4504                            com.liferay.portlet.journal.NoSuchArticleException {
4505                    return getPersistence()
4506                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
4507                            orderByComparator);
4508            }
4509    
4510            /**
4511            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4512            *
4513            * @param groupId the group ID
4514            * @param status the status
4515            * @throws SystemException if a system exception occurred
4516            */
4517            public static void removeByG_ST(long groupId, int status)
4518                    throws com.liferay.portal.kernel.exception.SystemException {
4519                    getPersistence().removeByG_ST(groupId, status);
4520            }
4521    
4522            /**
4523            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4524            *
4525            * @param groupId the group ID
4526            * @param status the status
4527            * @return the number of matching journal articles
4528            * @throws SystemException if a system exception occurred
4529            */
4530            public static int countByG_ST(long groupId, int status)
4531                    throws com.liferay.portal.kernel.exception.SystemException {
4532                    return getPersistence().countByG_ST(groupId, status);
4533            }
4534    
4535            /**
4536            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4537            *
4538            * @param groupId the group ID
4539            * @param status the status
4540            * @return the number of matching journal articles that the user has permission to view
4541            * @throws SystemException if a system exception occurred
4542            */
4543            public static int filterCountByG_ST(long groupId, int status)
4544                    throws com.liferay.portal.kernel.exception.SystemException {
4545                    return getPersistence().filterCountByG_ST(groupId, status);
4546            }
4547    
4548            /**
4549            * Returns all the journal articles where companyId = &#63; and version = &#63;.
4550            *
4551            * @param companyId the company ID
4552            * @param version the version
4553            * @return the matching journal articles
4554            * @throws SystemException if a system exception occurred
4555            */
4556            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4557                    long companyId, double version)
4558                    throws com.liferay.portal.kernel.exception.SystemException {
4559                    return getPersistence().findByC_V(companyId, version);
4560            }
4561    
4562            /**
4563            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4564            *
4565            * <p>
4566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4567            * </p>
4568            *
4569            * @param companyId the company ID
4570            * @param version the version
4571            * @param start the lower bound of the range of journal articles
4572            * @param end the upper bound of the range of journal articles (not inclusive)
4573            * @return the range of matching journal articles
4574            * @throws SystemException if a system exception occurred
4575            */
4576            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4577                    long companyId, double version, int start, int end)
4578                    throws com.liferay.portal.kernel.exception.SystemException {
4579                    return getPersistence().findByC_V(companyId, version, start, end);
4580            }
4581    
4582            /**
4583            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
4584            *
4585            * <p>
4586            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4587            * </p>
4588            *
4589            * @param companyId the company ID
4590            * @param version the version
4591            * @param start the lower bound of the range of journal articles
4592            * @param end the upper bound of the range of journal articles (not inclusive)
4593            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4594            * @return the ordered range of matching journal articles
4595            * @throws SystemException if a system exception occurred
4596            */
4597            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4598                    long companyId, double version, int start, int end,
4599                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4600                    throws com.liferay.portal.kernel.exception.SystemException {
4601                    return getPersistence()
4602                                       .findByC_V(companyId, version, start, end, orderByComparator);
4603            }
4604    
4605            /**
4606            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4607            *
4608            * @param companyId the company ID
4609            * @param version the version
4610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4611            * @return the first matching journal article
4612            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4613            * @throws SystemException if a system exception occurred
4614            */
4615            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
4616                    long companyId, double version,
4617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4618                    throws com.liferay.portal.kernel.exception.SystemException,
4619                            com.liferay.portlet.journal.NoSuchArticleException {
4620                    return getPersistence()
4621                                       .findByC_V_First(companyId, version, orderByComparator);
4622            }
4623    
4624            /**
4625            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4626            *
4627            * @param companyId the company ID
4628            * @param version the version
4629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4630            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4631            * @throws SystemException if a system exception occurred
4632            */
4633            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
4634                    long companyId, double version,
4635                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4636                    throws com.liferay.portal.kernel.exception.SystemException {
4637                    return getPersistence()
4638                                       .fetchByC_V_First(companyId, version, orderByComparator);
4639            }
4640    
4641            /**
4642            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4643            *
4644            * @param companyId the company ID
4645            * @param version the version
4646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4647            * @return the last matching journal article
4648            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4649            * @throws SystemException if a system exception occurred
4650            */
4651            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
4652                    long companyId, double version,
4653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4654                    throws com.liferay.portal.kernel.exception.SystemException,
4655                            com.liferay.portlet.journal.NoSuchArticleException {
4656                    return getPersistence()
4657                                       .findByC_V_Last(companyId, version, orderByComparator);
4658            }
4659    
4660            /**
4661            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4662            *
4663            * @param companyId the company ID
4664            * @param version the version
4665            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4666            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4667            * @throws SystemException if a system exception occurred
4668            */
4669            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
4670                    long companyId, double version,
4671                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4672                    throws com.liferay.portal.kernel.exception.SystemException {
4673                    return getPersistence()
4674                                       .fetchByC_V_Last(companyId, version, orderByComparator);
4675            }
4676    
4677            /**
4678            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
4679            *
4680            * @param id the primary key of the current journal article
4681            * @param companyId the company ID
4682            * @param version the version
4683            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4684            * @return the previous, current, and next journal article
4685            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4686            * @throws SystemException if a system exception occurred
4687            */
4688            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
4689                    long id, long companyId, double version,
4690                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4691                    throws com.liferay.portal.kernel.exception.SystemException,
4692                            com.liferay.portlet.journal.NoSuchArticleException {
4693                    return getPersistence()
4694                                       .findByC_V_PrevAndNext(id, companyId, version,
4695                            orderByComparator);
4696            }
4697    
4698            /**
4699            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4700            *
4701            * @param companyId the company ID
4702            * @param version the version
4703            * @throws SystemException if a system exception occurred
4704            */
4705            public static void removeByC_V(long companyId, double version)
4706                    throws com.liferay.portal.kernel.exception.SystemException {
4707                    getPersistence().removeByC_V(companyId, version);
4708            }
4709    
4710            /**
4711            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4712            *
4713            * @param companyId the company ID
4714            * @param version the version
4715            * @return the number of matching journal articles
4716            * @throws SystemException if a system exception occurred
4717            */
4718            public static int countByC_V(long companyId, double version)
4719                    throws com.liferay.portal.kernel.exception.SystemException {
4720                    return getPersistence().countByC_V(companyId, version);
4721            }
4722    
4723            /**
4724            * Returns all the journal articles where companyId = &#63; and status = &#63;.
4725            *
4726            * @param companyId the company ID
4727            * @param status the status
4728            * @return the matching journal articles
4729            * @throws SystemException if a system exception occurred
4730            */
4731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4732                    long companyId, int status)
4733                    throws com.liferay.portal.kernel.exception.SystemException {
4734                    return getPersistence().findByC_ST(companyId, status);
4735            }
4736    
4737            /**
4738            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
4739            *
4740            * <p>
4741            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4742            * </p>
4743            *
4744            * @param companyId the company ID
4745            * @param status the status
4746            * @param start the lower bound of the range of journal articles
4747            * @param end the upper bound of the range of journal articles (not inclusive)
4748            * @return the range of matching journal articles
4749            * @throws SystemException if a system exception occurred
4750            */
4751            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4752                    long companyId, int status, int start, int end)
4753                    throws com.liferay.portal.kernel.exception.SystemException {
4754                    return getPersistence().findByC_ST(companyId, status, start, end);
4755            }
4756    
4757            /**
4758            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
4759            *
4760            * <p>
4761            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4762            * </p>
4763            *
4764            * @param companyId the company ID
4765            * @param status the status
4766            * @param start the lower bound of the range of journal articles
4767            * @param end the upper bound of the range of journal articles (not inclusive)
4768            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4769            * @return the ordered range of matching journal articles
4770            * @throws SystemException if a system exception occurred
4771            */
4772            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4773                    long companyId, int status, int start, int end,
4774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4775                    throws com.liferay.portal.kernel.exception.SystemException {
4776                    return getPersistence()
4777                                       .findByC_ST(companyId, status, start, end, orderByComparator);
4778            }
4779    
4780            /**
4781            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4782            *
4783            * @param companyId the company ID
4784            * @param status the status
4785            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4786            * @return the first matching journal article
4787            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4788            * @throws SystemException if a system exception occurred
4789            */
4790            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
4791                    long companyId, int status,
4792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4793                    throws com.liferay.portal.kernel.exception.SystemException,
4794                            com.liferay.portlet.journal.NoSuchArticleException {
4795                    return getPersistence()
4796                                       .findByC_ST_First(companyId, status, orderByComparator);
4797            }
4798    
4799            /**
4800            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4801            *
4802            * @param companyId the company ID
4803            * @param status the status
4804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4805            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4806            * @throws SystemException if a system exception occurred
4807            */
4808            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
4809                    long companyId, int status,
4810                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4811                    throws com.liferay.portal.kernel.exception.SystemException {
4812                    return getPersistence()
4813                                       .fetchByC_ST_First(companyId, status, orderByComparator);
4814            }
4815    
4816            /**
4817            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4818            *
4819            * @param companyId the company ID
4820            * @param status the status
4821            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4822            * @return the last matching journal article
4823            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4824            * @throws SystemException if a system exception occurred
4825            */
4826            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
4827                    long companyId, int status,
4828                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4829                    throws com.liferay.portal.kernel.exception.SystemException,
4830                            com.liferay.portlet.journal.NoSuchArticleException {
4831                    return getPersistence()
4832                                       .findByC_ST_Last(companyId, status, orderByComparator);
4833            }
4834    
4835            /**
4836            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4837            *
4838            * @param companyId the company ID
4839            * @param status the status
4840            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4841            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4842            * @throws SystemException if a system exception occurred
4843            */
4844            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
4845                    long companyId, int status,
4846                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4847                    throws com.liferay.portal.kernel.exception.SystemException {
4848                    return getPersistence()
4849                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
4850            }
4851    
4852            /**
4853            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
4854            *
4855            * @param id the primary key of the current journal article
4856            * @param companyId the company ID
4857            * @param status the status
4858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4859            * @return the previous, current, and next journal article
4860            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4861            * @throws SystemException if a system exception occurred
4862            */
4863            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
4864                    long id, long companyId, int status,
4865                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4866                    throws com.liferay.portal.kernel.exception.SystemException,
4867                            com.liferay.portlet.journal.NoSuchArticleException {
4868                    return getPersistence()
4869                                       .findByC_ST_PrevAndNext(id, companyId, status,
4870                            orderByComparator);
4871            }
4872    
4873            /**
4874            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4875            *
4876            * @param companyId the company ID
4877            * @param status the status
4878            * @throws SystemException if a system exception occurred
4879            */
4880            public static void removeByC_ST(long companyId, int status)
4881                    throws com.liferay.portal.kernel.exception.SystemException {
4882                    getPersistence().removeByC_ST(companyId, status);
4883            }
4884    
4885            /**
4886            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4887            *
4888            * @param companyId the company ID
4889            * @param status the status
4890            * @return the number of matching journal articles
4891            * @throws SystemException if a system exception occurred
4892            */
4893            public static int countByC_ST(long companyId, int status)
4894                    throws com.liferay.portal.kernel.exception.SystemException {
4895                    return getPersistence().countByC_ST(companyId, status);
4896            }
4897    
4898            /**
4899            * Returns all the journal articles where companyId = &#63; and status &ne; &#63;.
4900            *
4901            * @param companyId the company ID
4902            * @param status the status
4903            * @return the matching journal articles
4904            * @throws SystemException if a system exception occurred
4905            */
4906            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4907                    long companyId, int status)
4908                    throws com.liferay.portal.kernel.exception.SystemException {
4909                    return getPersistence().findByC_NotST(companyId, status);
4910            }
4911    
4912            /**
4913            * Returns a range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4914            *
4915            * <p>
4916            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4917            * </p>
4918            *
4919            * @param companyId the company ID
4920            * @param status the status
4921            * @param start the lower bound of the range of journal articles
4922            * @param end the upper bound of the range of journal articles (not inclusive)
4923            * @return the range of matching journal articles
4924            * @throws SystemException if a system exception occurred
4925            */
4926            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4927                    long companyId, int status, int start, int end)
4928                    throws com.liferay.portal.kernel.exception.SystemException {
4929                    return getPersistence().findByC_NotST(companyId, status, start, end);
4930            }
4931    
4932            /**
4933            * Returns an ordered range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4934            *
4935            * <p>
4936            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4937            * </p>
4938            *
4939            * @param companyId the company ID
4940            * @param status the status
4941            * @param start the lower bound of the range of journal articles
4942            * @param end the upper bound of the range of journal articles (not inclusive)
4943            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4944            * @return the ordered range of matching journal articles
4945            * @throws SystemException if a system exception occurred
4946            */
4947            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4948                    long companyId, int status, int start, int end,
4949                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4950                    throws com.liferay.portal.kernel.exception.SystemException {
4951                    return getPersistence()
4952                                       .findByC_NotST(companyId, status, start, end,
4953                            orderByComparator);
4954            }
4955    
4956            /**
4957            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4958            *
4959            * @param companyId the company ID
4960            * @param status the status
4961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4962            * @return the first matching journal article
4963            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4964            * @throws SystemException if a system exception occurred
4965            */
4966            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First(
4967                    long companyId, int status,
4968                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4969                    throws com.liferay.portal.kernel.exception.SystemException,
4970                            com.liferay.portlet.journal.NoSuchArticleException {
4971                    return getPersistence()
4972                                       .findByC_NotST_First(companyId, status, orderByComparator);
4973            }
4974    
4975            /**
4976            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4977            *
4978            * @param companyId the company ID
4979            * @param status the status
4980            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4981            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4982            * @throws SystemException if a system exception occurred
4983            */
4984            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First(
4985                    long companyId, int status,
4986                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4987                    throws com.liferay.portal.kernel.exception.SystemException {
4988                    return getPersistence()
4989                                       .fetchByC_NotST_First(companyId, status, orderByComparator);
4990            }
4991    
4992            /**
4993            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4994            *
4995            * @param companyId the company ID
4996            * @param status the status
4997            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4998            * @return the last matching journal article
4999            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5000            * @throws SystemException if a system exception occurred
5001            */
5002            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last(
5003                    long companyId, int status,
5004                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5005                    throws com.liferay.portal.kernel.exception.SystemException,
5006                            com.liferay.portlet.journal.NoSuchArticleException {
5007                    return getPersistence()
5008                                       .findByC_NotST_Last(companyId, status, orderByComparator);
5009            }
5010    
5011            /**
5012            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5013            *
5014            * @param companyId the company ID
5015            * @param status the status
5016            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5017            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5018            * @throws SystemException if a system exception occurred
5019            */
5020            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last(
5021                    long companyId, int status,
5022                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5023                    throws com.liferay.portal.kernel.exception.SystemException {
5024                    return getPersistence()
5025                                       .fetchByC_NotST_Last(companyId, status, orderByComparator);
5026            }
5027    
5028            /**
5029            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5030            *
5031            * @param id the primary key of the current journal article
5032            * @param companyId the company ID
5033            * @param status the status
5034            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5035            * @return the previous, current, and next journal article
5036            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5037            * @throws SystemException if a system exception occurred
5038            */
5039            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext(
5040                    long id, long companyId, int status,
5041                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5042                    throws com.liferay.portal.kernel.exception.SystemException,
5043                            com.liferay.portlet.journal.NoSuchArticleException {
5044                    return getPersistence()
5045                                       .findByC_NotST_PrevAndNext(id, companyId, status,
5046                            orderByComparator);
5047            }
5048    
5049            /**
5050            * Removes all the journal articles where companyId = &#63; and status &ne; &#63; from the database.
5051            *
5052            * @param companyId the company ID
5053            * @param status the status
5054            * @throws SystemException if a system exception occurred
5055            */
5056            public static void removeByC_NotST(long companyId, int status)
5057                    throws com.liferay.portal.kernel.exception.SystemException {
5058                    getPersistence().removeByC_NotST(companyId, status);
5059            }
5060    
5061            /**
5062            * Returns the number of journal articles where companyId = &#63; and status &ne; &#63;.
5063            *
5064            * @param companyId the company ID
5065            * @param status the status
5066            * @return the number of matching journal articles
5067            * @throws SystemException if a system exception occurred
5068            */
5069            public static int countByC_NotST(long companyId, int status)
5070                    throws com.liferay.portal.kernel.exception.SystemException {
5071                    return getPersistence().countByC_NotST(companyId, status);
5072            }
5073    
5074            /**
5075            * Returns all the journal articles where classNameId = &#63; and templateId = &#63;.
5076            *
5077            * @param classNameId the class name ID
5078            * @param templateId the template ID
5079            * @return the matching journal articles
5080            * @throws SystemException if a system exception occurred
5081            */
5082            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
5083                    long classNameId, java.lang.String templateId)
5084                    throws com.liferay.portal.kernel.exception.SystemException {
5085                    return getPersistence().findByC_T(classNameId, templateId);
5086            }
5087    
5088            /**
5089            * Returns a range of all the journal articles where classNameId = &#63; and templateId = &#63;.
5090            *
5091            * <p>
5092            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5093            * </p>
5094            *
5095            * @param classNameId the class name ID
5096            * @param templateId the template ID
5097            * @param start the lower bound of the range of journal articles
5098            * @param end the upper bound of the range of journal articles (not inclusive)
5099            * @return the range of matching journal articles
5100            * @throws SystemException if a system exception occurred
5101            */
5102            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
5103                    long classNameId, java.lang.String templateId, int start, int end)
5104                    throws com.liferay.portal.kernel.exception.SystemException {
5105                    return getPersistence().findByC_T(classNameId, templateId, start, end);
5106            }
5107    
5108            /**
5109            * Returns an ordered range of all the journal articles where classNameId = &#63; and templateId = &#63;.
5110            *
5111            * <p>
5112            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5113            * </p>
5114            *
5115            * @param classNameId the class name ID
5116            * @param templateId the template ID
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            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5120            * @return the ordered range of matching journal articles
5121            * @throws SystemException if a system exception occurred
5122            */
5123            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
5124                    long classNameId, java.lang.String templateId, int start, int end,
5125                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5126                    throws com.liferay.portal.kernel.exception.SystemException {
5127                    return getPersistence()
5128                                       .findByC_T(classNameId, templateId, start, end,
5129                            orderByComparator);
5130            }
5131    
5132            /**
5133            * Returns the first journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5134            *
5135            * @param classNameId the class name ID
5136            * @param templateId the template ID
5137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5138            * @return the first matching journal article
5139            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5140            * @throws SystemException if a system exception occurred
5141            */
5142            public static com.liferay.portlet.journal.model.JournalArticle findByC_T_First(
5143                    long classNameId, java.lang.String templateId,
5144                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5145                    throws com.liferay.portal.kernel.exception.SystemException,
5146                            com.liferay.portlet.journal.NoSuchArticleException {
5147                    return getPersistence()
5148                                       .findByC_T_First(classNameId, templateId, orderByComparator);
5149            }
5150    
5151            /**
5152            * Returns the first journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5153            *
5154            * @param classNameId the class name ID
5155            * @param templateId the template ID
5156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5157            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5158            * @throws SystemException if a system exception occurred
5159            */
5160            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_First(
5161                    long classNameId, java.lang.String templateId,
5162                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5163                    throws com.liferay.portal.kernel.exception.SystemException {
5164                    return getPersistence()
5165                                       .fetchByC_T_First(classNameId, templateId, orderByComparator);
5166            }
5167    
5168            /**
5169            * Returns the last journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5170            *
5171            * @param classNameId the class name ID
5172            * @param templateId the template ID
5173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5174            * @return the last matching journal article
5175            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5176            * @throws SystemException if a system exception occurred
5177            */
5178            public static com.liferay.portlet.journal.model.JournalArticle findByC_T_Last(
5179                    long classNameId, java.lang.String templateId,
5180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5181                    throws com.liferay.portal.kernel.exception.SystemException,
5182                            com.liferay.portlet.journal.NoSuchArticleException {
5183                    return getPersistence()
5184                                       .findByC_T_Last(classNameId, templateId, orderByComparator);
5185            }
5186    
5187            /**
5188            * Returns the last journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5189            *
5190            * @param classNameId the class name ID
5191            * @param templateId the template ID
5192            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5193            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5194            * @throws SystemException if a system exception occurred
5195            */
5196            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_Last(
5197                    long classNameId, java.lang.String templateId,
5198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5199                    throws com.liferay.portal.kernel.exception.SystemException {
5200                    return getPersistence()
5201                                       .fetchByC_T_Last(classNameId, templateId, orderByComparator);
5202            }
5203    
5204            /**
5205            * Returns the journal articles before and after the current journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5206            *
5207            * @param id the primary key of the current journal article
5208            * @param classNameId the class name ID
5209            * @param templateId the template ID
5210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5211            * @return the previous, current, and next journal article
5212            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5213            * @throws SystemException if a system exception occurred
5214            */
5215            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_T_PrevAndNext(
5216                    long id, long classNameId, java.lang.String templateId,
5217                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5218                    throws com.liferay.portal.kernel.exception.SystemException,
5219                            com.liferay.portlet.journal.NoSuchArticleException {
5220                    return getPersistence()
5221                                       .findByC_T_PrevAndNext(id, classNameId, templateId,
5222                            orderByComparator);
5223            }
5224    
5225            /**
5226            * Removes all the journal articles where classNameId = &#63; and templateId = &#63; from the database.
5227            *
5228            * @param classNameId the class name ID
5229            * @param templateId the template ID
5230            * @throws SystemException if a system exception occurred
5231            */
5232            public static void removeByC_T(long classNameId, java.lang.String templateId)
5233                    throws com.liferay.portal.kernel.exception.SystemException {
5234                    getPersistence().removeByC_T(classNameId, templateId);
5235            }
5236    
5237            /**
5238            * Returns the number of journal articles where classNameId = &#63; and templateId = &#63;.
5239            *
5240            * @param classNameId the class name ID
5241            * @param templateId the template ID
5242            * @return the number of matching journal articles
5243            * @throws SystemException if a system exception occurred
5244            */
5245            public static int countByC_T(long classNameId, java.lang.String templateId)
5246                    throws com.liferay.portal.kernel.exception.SystemException {
5247                    return getPersistence().countByC_T(classNameId, templateId);
5248            }
5249    
5250            /**
5251            * Returns all the journal articles where displayDate &lt; &#63; and status = &#63;.
5252            *
5253            * @param displayDate the display date
5254            * @param status the status
5255            * @return the matching journal articles
5256            * @throws SystemException if a system exception occurred
5257            */
5258            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
5259                    java.util.Date displayDate, int status)
5260                    throws com.liferay.portal.kernel.exception.SystemException {
5261                    return getPersistence().findByLtD_S(displayDate, status);
5262            }
5263    
5264            /**
5265            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
5266            *
5267            * <p>
5268            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5269            * </p>
5270            *
5271            * @param displayDate the display date
5272            * @param status the status
5273            * @param start the lower bound of the range of journal articles
5274            * @param end the upper bound of the range of journal articles (not inclusive)
5275            * @return the range of matching journal articles
5276            * @throws SystemException if a system exception occurred
5277            */
5278            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
5279                    java.util.Date displayDate, int status, int start, int end)
5280                    throws com.liferay.portal.kernel.exception.SystemException {
5281                    return getPersistence().findByLtD_S(displayDate, status, start, end);
5282            }
5283    
5284            /**
5285            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
5286            *
5287            * <p>
5288            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5289            * </p>
5290            *
5291            * @param displayDate the display date
5292            * @param status the status
5293            * @param start the lower bound of the range of journal articles
5294            * @param end the upper bound of the range of journal articles (not inclusive)
5295            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5296            * @return the ordered range of matching journal articles
5297            * @throws SystemException if a system exception occurred
5298            */
5299            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
5300                    java.util.Date displayDate, int status, int start, int end,
5301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5302                    throws com.liferay.portal.kernel.exception.SystemException {
5303                    return getPersistence()
5304                                       .findByLtD_S(displayDate, status, start, end,
5305                            orderByComparator);
5306            }
5307    
5308            /**
5309            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5310            *
5311            * @param displayDate the display date
5312            * @param status the status
5313            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5314            * @return the first matching journal article
5315            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5316            * @throws SystemException if a system exception occurred
5317            */
5318            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First(
5319                    java.util.Date displayDate, int status,
5320                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5321                    throws com.liferay.portal.kernel.exception.SystemException,
5322                            com.liferay.portlet.journal.NoSuchArticleException {
5323                    return getPersistence()
5324                                       .findByLtD_S_First(displayDate, status, orderByComparator);
5325            }
5326    
5327            /**
5328            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5329            *
5330            * @param displayDate the display date
5331            * @param status the status
5332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5333            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5334            * @throws SystemException if a system exception occurred
5335            */
5336            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First(
5337                    java.util.Date displayDate, int status,
5338                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5339                    throws com.liferay.portal.kernel.exception.SystemException {
5340                    return getPersistence()
5341                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
5342            }
5343    
5344            /**
5345            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5346            *
5347            * @param displayDate the display date
5348            * @param status the status
5349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5350            * @return the last matching journal article
5351            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5352            * @throws SystemException if a system exception occurred
5353            */
5354            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last(
5355                    java.util.Date displayDate, int status,
5356                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5357                    throws com.liferay.portal.kernel.exception.SystemException,
5358                            com.liferay.portlet.journal.NoSuchArticleException {
5359                    return getPersistence()
5360                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
5361            }
5362    
5363            /**
5364            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5365            *
5366            * @param displayDate the display date
5367            * @param status the status
5368            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5369            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5370            * @throws SystemException if a system exception occurred
5371            */
5372            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last(
5373                    java.util.Date displayDate, int status,
5374                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5375                    throws com.liferay.portal.kernel.exception.SystemException {
5376                    return getPersistence()
5377                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
5378            }
5379    
5380            /**
5381            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5382            *
5383            * @param id the primary key of the current journal article
5384            * @param displayDate the display date
5385            * @param status the status
5386            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5387            * @return the previous, current, and next journal article
5388            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5389            * @throws SystemException if a system exception occurred
5390            */
5391            public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext(
5392                    long id, java.util.Date displayDate, int status,
5393                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5394                    throws com.liferay.portal.kernel.exception.SystemException,
5395                            com.liferay.portlet.journal.NoSuchArticleException {
5396                    return getPersistence()
5397                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
5398                            orderByComparator);
5399            }
5400    
5401            /**
5402            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
5403            *
5404            * @param displayDate the display date
5405            * @param status the status
5406            * @throws SystemException if a system exception occurred
5407            */
5408            public static void removeByLtD_S(java.util.Date displayDate, int status)
5409                    throws com.liferay.portal.kernel.exception.SystemException {
5410                    getPersistence().removeByLtD_S(displayDate, status);
5411            }
5412    
5413            /**
5414            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
5415            *
5416            * @param displayDate the display date
5417            * @param status the status
5418            * @return the number of matching journal articles
5419            * @throws SystemException if a system exception occurred
5420            */
5421            public static int countByLtD_S(java.util.Date displayDate, int status)
5422                    throws com.liferay.portal.kernel.exception.SystemException {
5423                    return getPersistence().countByLtD_S(displayDate, status);
5424            }
5425    
5426            /**
5427            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5428            *
5429            * @param resourcePrimKey the resource prim key
5430            * @param indexable the indexable
5431            * @param status the status
5432            * @return the matching journal articles
5433            * @throws SystemException if a system exception occurred
5434            */
5435            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5436                    long resourcePrimKey, boolean indexable, int status)
5437                    throws com.liferay.portal.kernel.exception.SystemException {
5438                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
5439            }
5440    
5441            /**
5442            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5443            *
5444            * <p>
5445            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5446            * </p>
5447            *
5448            * @param resourcePrimKey the resource prim key
5449            * @param indexable the indexable
5450            * @param status the status
5451            * @param start the lower bound of the range of journal articles
5452            * @param end the upper bound of the range of journal articles (not inclusive)
5453            * @return the range of matching journal articles
5454            * @throws SystemException if a system exception occurred
5455            */
5456            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5457                    long resourcePrimKey, boolean indexable, int status, int start, int end)
5458                    throws com.liferay.portal.kernel.exception.SystemException {
5459                    return getPersistence()
5460                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
5461            }
5462    
5463            /**
5464            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5465            *
5466            * <p>
5467            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5468            * </p>
5469            *
5470            * @param resourcePrimKey the resource prim key
5471            * @param indexable the indexable
5472            * @param status the status
5473            * @param start the lower bound of the range of journal articles
5474            * @param end the upper bound of the range of journal articles (not inclusive)
5475            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5476            * @return the ordered range of matching journal articles
5477            * @throws SystemException if a system exception occurred
5478            */
5479            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5480                    long resourcePrimKey, boolean indexable, int status, int start,
5481                    int end,
5482                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5483                    throws com.liferay.portal.kernel.exception.SystemException {
5484                    return getPersistence()
5485                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
5486                            orderByComparator);
5487            }
5488    
5489            /**
5490            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5491            *
5492            * @param resourcePrimKey the resource prim key
5493            * @param indexable the indexable
5494            * @param status the status
5495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5496            * @return the first matching journal article
5497            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5498            * @throws SystemException if a system exception occurred
5499            */
5500            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First(
5501                    long resourcePrimKey, boolean indexable, int status,
5502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5503                    throws com.liferay.portal.kernel.exception.SystemException,
5504                            com.liferay.portlet.journal.NoSuchArticleException {
5505                    return getPersistence()
5506                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
5507                            orderByComparator);
5508            }
5509    
5510            /**
5511            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5512            *
5513            * @param resourcePrimKey the resource prim key
5514            * @param indexable the indexable
5515            * @param status the status
5516            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5517            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5518            * @throws SystemException if a system exception occurred
5519            */
5520            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First(
5521                    long resourcePrimKey, boolean indexable, int status,
5522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5523                    throws com.liferay.portal.kernel.exception.SystemException {
5524                    return getPersistence()
5525                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
5526                            orderByComparator);
5527            }
5528    
5529            /**
5530            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5531            *
5532            * @param resourcePrimKey the resource prim key
5533            * @param indexable the indexable
5534            * @param status the status
5535            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5536            * @return the last matching journal article
5537            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5538            * @throws SystemException if a system exception occurred
5539            */
5540            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last(
5541                    long resourcePrimKey, boolean indexable, int status,
5542                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5543                    throws com.liferay.portal.kernel.exception.SystemException,
5544                            com.liferay.portlet.journal.NoSuchArticleException {
5545                    return getPersistence()
5546                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
5547                            orderByComparator);
5548            }
5549    
5550            /**
5551            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5552            *
5553            * @param resourcePrimKey the resource prim key
5554            * @param indexable the indexable
5555            * @param status the status
5556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5557            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5558            * @throws SystemException if a system exception occurred
5559            */
5560            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last(
5561                    long resourcePrimKey, boolean indexable, int status,
5562                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5563                    throws com.liferay.portal.kernel.exception.SystemException {
5564                    return getPersistence()
5565                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
5566                            orderByComparator);
5567            }
5568    
5569            /**
5570            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5571            *
5572            * @param id the primary key of the current journal article
5573            * @param resourcePrimKey the resource prim key
5574            * @param indexable the indexable
5575            * @param status the status
5576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5577            * @return the previous, current, and next journal article
5578            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5579            * @throws SystemException if a system exception occurred
5580            */
5581            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext(
5582                    long id, long resourcePrimKey, boolean indexable, int status,
5583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5584                    throws com.liferay.portal.kernel.exception.SystemException,
5585                            com.liferay.portlet.journal.NoSuchArticleException {
5586                    return getPersistence()
5587                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
5588                            status, orderByComparator);
5589            }
5590    
5591            /**
5592            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5593            *
5594            * <p>
5595            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5596            * </p>
5597            *
5598            * @param resourcePrimKey the resource prim key
5599            * @param indexable the indexable
5600            * @param statuses the statuses
5601            * @return the matching journal articles
5602            * @throws SystemException if a system exception occurred
5603            */
5604            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5605                    long resourcePrimKey, boolean indexable, int[] statuses)
5606                    throws com.liferay.portal.kernel.exception.SystemException {
5607                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
5608            }
5609    
5610            /**
5611            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5612            *
5613            * <p>
5614            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5615            * </p>
5616            *
5617            * @param resourcePrimKey the resource prim key
5618            * @param indexable the indexable
5619            * @param statuses the statuses
5620            * @param start the lower bound of the range of journal articles
5621            * @param end the upper bound of the range of journal articles (not inclusive)
5622            * @return the range of matching journal articles
5623            * @throws SystemException if a system exception occurred
5624            */
5625            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5626                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5627                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5628                    return getPersistence()
5629                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
5630            }
5631    
5632            /**
5633            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5634            *
5635            * <p>
5636            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5637            * </p>
5638            *
5639            * @param resourcePrimKey the resource prim key
5640            * @param indexable the indexable
5641            * @param statuses the statuses
5642            * @param start the lower bound of the range of journal articles
5643            * @param end the upper bound of the range of journal articles (not inclusive)
5644            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5645            * @return the ordered range of matching journal articles
5646            * @throws SystemException if a system exception occurred
5647            */
5648            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5649                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5650                    int end,
5651                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5652                    throws com.liferay.portal.kernel.exception.SystemException {
5653                    return getPersistence()
5654                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
5655                            end, orderByComparator);
5656            }
5657    
5658            /**
5659            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
5660            *
5661            * @param resourcePrimKey the resource prim key
5662            * @param indexable the indexable
5663            * @param status the status
5664            * @throws SystemException if a system exception occurred
5665            */
5666            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
5667                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5668                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
5669            }
5670    
5671            /**
5672            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5673            *
5674            * @param resourcePrimKey the resource prim key
5675            * @param indexable the indexable
5676            * @param status the status
5677            * @return the number of matching journal articles
5678            * @throws SystemException if a system exception occurred
5679            */
5680            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5681                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5682                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
5683            }
5684    
5685            /**
5686            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5687            *
5688            * @param resourcePrimKey the resource prim key
5689            * @param indexable the indexable
5690            * @param statuses the statuses
5691            * @return the number of matching journal articles
5692            * @throws SystemException if a system exception occurred
5693            */
5694            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5695                    int[] statuses)
5696                    throws com.liferay.portal.kernel.exception.SystemException {
5697                    return getPersistence()
5698                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
5699            }
5700    
5701            /**
5702            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5703            *
5704            * @param groupId the group ID
5705            * @param userId the user ID
5706            * @param classNameId the class name ID
5707            * @return the matching journal articles
5708            * @throws SystemException if a system exception occurred
5709            */
5710            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5711                    long groupId, long userId, long classNameId)
5712                    throws com.liferay.portal.kernel.exception.SystemException {
5713                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
5714            }
5715    
5716            /**
5717            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5718            *
5719            * <p>
5720            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5721            * </p>
5722            *
5723            * @param groupId the group ID
5724            * @param userId the user ID
5725            * @param classNameId the class name ID
5726            * @param start the lower bound of the range of journal articles
5727            * @param end the upper bound of the range of journal articles (not inclusive)
5728            * @return the range of matching journal articles
5729            * @throws SystemException if a system exception occurred
5730            */
5731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5732                    long groupId, long userId, long classNameId, int start, int end)
5733                    throws com.liferay.portal.kernel.exception.SystemException {
5734                    return getPersistence()
5735                                       .findByG_U_C(groupId, userId, classNameId, start, end);
5736            }
5737    
5738            /**
5739            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5740            *
5741            * <p>
5742            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5743            * </p>
5744            *
5745            * @param groupId the group ID
5746            * @param userId the user ID
5747            * @param classNameId the class name ID
5748            * @param start the lower bound of the range of journal articles
5749            * @param end the upper bound of the range of journal articles (not inclusive)
5750            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5751            * @return the ordered range of matching journal articles
5752            * @throws SystemException if a system exception occurred
5753            */
5754            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5755                    long groupId, long userId, long classNameId, int start, int end,
5756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5757                    throws com.liferay.portal.kernel.exception.SystemException {
5758                    return getPersistence()
5759                                       .findByG_U_C(groupId, userId, classNameId, start, end,
5760                            orderByComparator);
5761            }
5762    
5763            /**
5764            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5765            *
5766            * @param groupId the group ID
5767            * @param userId the user ID
5768            * @param classNameId the class name ID
5769            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5770            * @return the first matching journal article
5771            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5772            * @throws SystemException if a system exception occurred
5773            */
5774            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
5775                    long groupId, long userId, long classNameId,
5776                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5777                    throws com.liferay.portal.kernel.exception.SystemException,
5778                            com.liferay.portlet.journal.NoSuchArticleException {
5779                    return getPersistence()
5780                                       .findByG_U_C_First(groupId, userId, classNameId,
5781                            orderByComparator);
5782            }
5783    
5784            /**
5785            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5786            *
5787            * @param groupId the group ID
5788            * @param userId the user ID
5789            * @param classNameId the class name ID
5790            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5791            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5792            * @throws SystemException if a system exception occurred
5793            */
5794            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
5795                    long groupId, long userId, long classNameId,
5796                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5797                    throws com.liferay.portal.kernel.exception.SystemException {
5798                    return getPersistence()
5799                                       .fetchByG_U_C_First(groupId, userId, classNameId,
5800                            orderByComparator);
5801            }
5802    
5803            /**
5804            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5805            *
5806            * @param groupId the group ID
5807            * @param userId the user ID
5808            * @param classNameId the class name ID
5809            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5810            * @return the last matching journal article
5811            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5812            * @throws SystemException if a system exception occurred
5813            */
5814            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
5815                    long groupId, long userId, long classNameId,
5816                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5817                    throws com.liferay.portal.kernel.exception.SystemException,
5818                            com.liferay.portlet.journal.NoSuchArticleException {
5819                    return getPersistence()
5820                                       .findByG_U_C_Last(groupId, userId, classNameId,
5821                            orderByComparator);
5822            }
5823    
5824            /**
5825            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5826            *
5827            * @param groupId the group ID
5828            * @param userId the user ID
5829            * @param classNameId the class name ID
5830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5831            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5832            * @throws SystemException if a system exception occurred
5833            */
5834            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
5835                    long groupId, long userId, long classNameId,
5836                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5837                    throws com.liferay.portal.kernel.exception.SystemException {
5838                    return getPersistence()
5839                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
5840                            orderByComparator);
5841            }
5842    
5843            /**
5844            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5845            *
5846            * @param id the primary key of the current journal article
5847            * @param groupId the group ID
5848            * @param userId the user ID
5849            * @param classNameId the class name ID
5850            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5851            * @return the previous, current, and next journal article
5852            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5853            * @throws SystemException if a system exception occurred
5854            */
5855            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
5856                    long id, long groupId, long userId, long classNameId,
5857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5858                    throws com.liferay.portal.kernel.exception.SystemException,
5859                            com.liferay.portlet.journal.NoSuchArticleException {
5860                    return getPersistence()
5861                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
5862                            orderByComparator);
5863            }
5864    
5865            /**
5866            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5867            *
5868            * @param groupId the group ID
5869            * @param userId the user ID
5870            * @param classNameId the class name ID
5871            * @return the matching journal articles that the user has permission to view
5872            * @throws SystemException if a system exception occurred
5873            */
5874            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5875                    long groupId, long userId, long classNameId)
5876                    throws com.liferay.portal.kernel.exception.SystemException {
5877                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
5878            }
5879    
5880            /**
5881            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5882            *
5883            * <p>
5884            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5885            * </p>
5886            *
5887            * @param groupId the group ID
5888            * @param userId the user ID
5889            * @param classNameId the class name ID
5890            * @param start the lower bound of the range of journal articles
5891            * @param end the upper bound of the range of journal articles (not inclusive)
5892            * @return the range of matching journal articles that the user has permission to view
5893            * @throws SystemException if a system exception occurred
5894            */
5895            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5896                    long groupId, long userId, long classNameId, int start, int end)
5897                    throws com.liferay.portal.kernel.exception.SystemException {
5898                    return getPersistence()
5899                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
5900            }
5901    
5902            /**
5903            * 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;.
5904            *
5905            * <p>
5906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5907            * </p>
5908            *
5909            * @param groupId the group ID
5910            * @param userId the user ID
5911            * @param classNameId the class name ID
5912            * @param start the lower bound of the range of journal articles
5913            * @param end the upper bound of the range of journal articles (not inclusive)
5914            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5915            * @return the ordered range of matching journal articles that the user has permission to view
5916            * @throws SystemException if a system exception occurred
5917            */
5918            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5919                    long groupId, long userId, long classNameId, int start, int end,
5920                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5921                    throws com.liferay.portal.kernel.exception.SystemException {
5922                    return getPersistence()
5923                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
5924                            orderByComparator);
5925            }
5926    
5927            /**
5928            * 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;.
5929            *
5930            * @param id the primary key of the current journal article
5931            * @param groupId the group ID
5932            * @param userId the user ID
5933            * @param classNameId the class name ID
5934            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5935            * @return the previous, current, and next journal article
5936            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5937            * @throws SystemException if a system exception occurred
5938            */
5939            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
5940                    long id, long groupId, long userId, long classNameId,
5941                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5942                    throws com.liferay.portal.kernel.exception.SystemException,
5943                            com.liferay.portlet.journal.NoSuchArticleException {
5944                    return getPersistence()
5945                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
5946                            classNameId, orderByComparator);
5947            }
5948    
5949            /**
5950            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
5951            *
5952            * @param groupId the group ID
5953            * @param userId the user ID
5954            * @param classNameId the class name ID
5955            * @throws SystemException if a system exception occurred
5956            */
5957            public static void removeByG_U_C(long groupId, long userId, long classNameId)
5958                    throws com.liferay.portal.kernel.exception.SystemException {
5959                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
5960            }
5961    
5962            /**
5963            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5964            *
5965            * @param groupId the group ID
5966            * @param userId the user ID
5967            * @param classNameId the class name ID
5968            * @return the number of matching journal articles
5969            * @throws SystemException if a system exception occurred
5970            */
5971            public static int countByG_U_C(long groupId, long userId, long classNameId)
5972                    throws com.liferay.portal.kernel.exception.SystemException {
5973                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
5974            }
5975    
5976            /**
5977            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5978            *
5979            * @param groupId the group ID
5980            * @param userId the user ID
5981            * @param classNameId the class name ID
5982            * @return the number of matching journal articles that the user has permission to view
5983            * @throws SystemException if a system exception occurred
5984            */
5985            public static int filterCountByG_U_C(long groupId, long userId,
5986                    long classNameId)
5987                    throws com.liferay.portal.kernel.exception.SystemException {
5988                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
5989            }
5990    
5991            /**
5992            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5993            *
5994            * @param groupId the group ID
5995            * @param folderId the folder ID
5996            * @param status the status
5997            * @return the matching journal articles
5998            * @throws SystemException if a system exception occurred
5999            */
6000            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6001                    long groupId, long folderId, int status)
6002                    throws com.liferay.portal.kernel.exception.SystemException {
6003                    return getPersistence().findByG_F_ST(groupId, folderId, status);
6004            }
6005    
6006            /**
6007            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6008            *
6009            * <p>
6010            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6011            * </p>
6012            *
6013            * @param groupId the group ID
6014            * @param folderId the folder ID
6015            * @param status the status
6016            * @param start the lower bound of the range of journal articles
6017            * @param end the upper bound of the range of journal articles (not inclusive)
6018            * @return the range of matching journal articles
6019            * @throws SystemException if a system exception occurred
6020            */
6021            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6022                    long groupId, long folderId, int status, int start, int end)
6023                    throws com.liferay.portal.kernel.exception.SystemException {
6024                    return getPersistence()
6025                                       .findByG_F_ST(groupId, folderId, status, start, end);
6026            }
6027    
6028            /**
6029            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6030            *
6031            * <p>
6032            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6033            * </p>
6034            *
6035            * @param groupId the group ID
6036            * @param folderId the folder ID
6037            * @param status the status
6038            * @param start the lower bound of the range of journal articles
6039            * @param end the upper bound of the range of journal articles (not inclusive)
6040            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6041            * @return the ordered range of matching journal articles
6042            * @throws SystemException if a system exception occurred
6043            */
6044            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6045                    long groupId, long folderId, int status, int start, int end,
6046                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6047                    throws com.liferay.portal.kernel.exception.SystemException {
6048                    return getPersistence()
6049                                       .findByG_F_ST(groupId, folderId, status, start, end,
6050                            orderByComparator);
6051            }
6052    
6053            /**
6054            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6055            *
6056            * @param groupId the group ID
6057            * @param folderId the folder ID
6058            * @param status the status
6059            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6060            * @return the first matching journal article
6061            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6062            * @throws SystemException if a system exception occurred
6063            */
6064            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
6065                    long groupId, long folderId, int status,
6066                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6067                    throws com.liferay.portal.kernel.exception.SystemException,
6068                            com.liferay.portlet.journal.NoSuchArticleException {
6069                    return getPersistence()
6070                                       .findByG_F_ST_First(groupId, folderId, status,
6071                            orderByComparator);
6072            }
6073    
6074            /**
6075            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6076            *
6077            * @param groupId the group ID
6078            * @param folderId the folder ID
6079            * @param status the status
6080            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6081            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6082            * @throws SystemException if a system exception occurred
6083            */
6084            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
6085                    long groupId, long folderId, int status,
6086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6087                    throws com.liferay.portal.kernel.exception.SystemException {
6088                    return getPersistence()
6089                                       .fetchByG_F_ST_First(groupId, folderId, status,
6090                            orderByComparator);
6091            }
6092    
6093            /**
6094            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6095            *
6096            * @param groupId the group ID
6097            * @param folderId the folder ID
6098            * @param status the status
6099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6100            * @return the last matching journal article
6101            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6102            * @throws SystemException if a system exception occurred
6103            */
6104            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
6105                    long groupId, long folderId, int status,
6106                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6107                    throws com.liferay.portal.kernel.exception.SystemException,
6108                            com.liferay.portlet.journal.NoSuchArticleException {
6109                    return getPersistence()
6110                                       .findByG_F_ST_Last(groupId, folderId, status,
6111                            orderByComparator);
6112            }
6113    
6114            /**
6115            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6116            *
6117            * @param groupId the group ID
6118            * @param folderId the folder ID
6119            * @param status the status
6120            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6121            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6122            * @throws SystemException if a system exception occurred
6123            */
6124            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
6125                    long groupId, long folderId, int status,
6126                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6127                    throws com.liferay.portal.kernel.exception.SystemException {
6128                    return getPersistence()
6129                                       .fetchByG_F_ST_Last(groupId, folderId, status,
6130                            orderByComparator);
6131            }
6132    
6133            /**
6134            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6135            *
6136            * @param id the primary key of the current journal article
6137            * @param groupId the group ID
6138            * @param folderId the folder ID
6139            * @param status the status
6140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6141            * @return the previous, current, and next journal article
6142            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6143            * @throws SystemException if a system exception occurred
6144            */
6145            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
6146                    long id, long groupId, long folderId, int status,
6147                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6148                    throws com.liferay.portal.kernel.exception.SystemException,
6149                            com.liferay.portlet.journal.NoSuchArticleException {
6150                    return getPersistence()
6151                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
6152                            orderByComparator);
6153            }
6154    
6155            /**
6156            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6157            *
6158            * @param groupId the group ID
6159            * @param folderId the folder ID
6160            * @param status the status
6161            * @return the matching journal articles that the user has permission to view
6162            * @throws SystemException if a system exception occurred
6163            */
6164            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6165                    long groupId, long folderId, int status)
6166                    throws com.liferay.portal.kernel.exception.SystemException {
6167                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
6168            }
6169    
6170            /**
6171            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6172            *
6173            * <p>
6174            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6175            * </p>
6176            *
6177            * @param groupId the group ID
6178            * @param folderId the folder ID
6179            * @param status the status
6180            * @param start the lower bound of the range of journal articles
6181            * @param end the upper bound of the range of journal articles (not inclusive)
6182            * @return the range of matching journal articles that the user has permission to view
6183            * @throws SystemException if a system exception occurred
6184            */
6185            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6186                    long groupId, long folderId, int status, int start, int end)
6187                    throws com.liferay.portal.kernel.exception.SystemException {
6188                    return getPersistence()
6189                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
6190            }
6191    
6192            /**
6193            * 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;.
6194            *
6195            * <p>
6196            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6197            * </p>
6198            *
6199            * @param groupId the group ID
6200            * @param folderId the folder ID
6201            * @param status the status
6202            * @param start the lower bound of the range of journal articles
6203            * @param end the upper bound of the range of journal articles (not inclusive)
6204            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6205            * @return the ordered range of matching journal articles that the user has permission to view
6206            * @throws SystemException if a system exception occurred
6207            */
6208            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6209                    long groupId, long folderId, int status, int start, int end,
6210                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6211                    throws com.liferay.portal.kernel.exception.SystemException {
6212                    return getPersistence()
6213                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
6214                            orderByComparator);
6215            }
6216    
6217            /**
6218            * 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;.
6219            *
6220            * @param id the primary key of the current journal article
6221            * @param groupId the group ID
6222            * @param folderId the folder ID
6223            * @param status the status
6224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6225            * @return the previous, current, and next journal article
6226            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6227            * @throws SystemException if a system exception occurred
6228            */
6229            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
6230                    long id, long groupId, long folderId, int status,
6231                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6232                    throws com.liferay.portal.kernel.exception.SystemException,
6233                            com.liferay.portlet.journal.NoSuchArticleException {
6234                    return getPersistence()
6235                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
6236                            status, orderByComparator);
6237            }
6238    
6239            /**
6240            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
6241            *
6242            * @param groupId the group ID
6243            * @param folderId the folder ID
6244            * @param statuses the statuses
6245            * @return the matching journal articles that the user has permission to view
6246            * @throws SystemException if a system exception occurred
6247            */
6248            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6249                    long groupId, long folderId, int[] statuses)
6250                    throws com.liferay.portal.kernel.exception.SystemException {
6251                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
6252            }
6253    
6254            /**
6255            * 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;.
6256            *
6257            * <p>
6258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6259            * </p>
6260            *
6261            * @param groupId the group ID
6262            * @param folderId the folder ID
6263            * @param statuses the statuses
6264            * @param start the lower bound of the range of journal articles
6265            * @param end the upper bound of the range of journal articles (not inclusive)
6266            * @return the range of matching journal articles that the user has permission to view
6267            * @throws SystemException if a system exception occurred
6268            */
6269            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6270                    long groupId, long folderId, int[] statuses, int start, int end)
6271                    throws com.liferay.portal.kernel.exception.SystemException {
6272                    return getPersistence()
6273                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
6274            }
6275    
6276            /**
6277            * 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;.
6278            *
6279            * <p>
6280            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6281            * </p>
6282            *
6283            * @param groupId the group ID
6284            * @param folderId the folder ID
6285            * @param statuses the statuses
6286            * @param start the lower bound of the range of journal articles
6287            * @param end the upper bound of the range of journal articles (not inclusive)
6288            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6289            * @return the ordered range of matching journal articles that the user has permission to view
6290            * @throws SystemException if a system exception occurred
6291            */
6292            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6293                    long groupId, long folderId, int[] statuses, int start, int end,
6294                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6295                    throws com.liferay.portal.kernel.exception.SystemException {
6296                    return getPersistence()
6297                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
6298                            orderByComparator);
6299            }
6300    
6301            /**
6302            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6303            *
6304            * <p>
6305            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6306            * </p>
6307            *
6308            * @param groupId the group ID
6309            * @param folderId the folder ID
6310            * @param statuses the statuses
6311            * @return the matching journal articles
6312            * @throws SystemException if a system exception occurred
6313            */
6314            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6315                    long groupId, long folderId, int[] statuses)
6316                    throws com.liferay.portal.kernel.exception.SystemException {
6317                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
6318            }
6319    
6320            /**
6321            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6322            *
6323            * <p>
6324            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6325            * </p>
6326            *
6327            * @param groupId the group ID
6328            * @param folderId the folder ID
6329            * @param statuses the statuses
6330            * @param start the lower bound of the range of journal articles
6331            * @param end the upper bound of the range of journal articles (not inclusive)
6332            * @return the range of matching journal articles
6333            * @throws SystemException if a system exception occurred
6334            */
6335            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6336                    long groupId, long folderId, int[] statuses, int start, int end)
6337                    throws com.liferay.portal.kernel.exception.SystemException {
6338                    return getPersistence()
6339                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
6340            }
6341    
6342            /**
6343            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6344            *
6345            * <p>
6346            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6347            * </p>
6348            *
6349            * @param groupId the group ID
6350            * @param folderId the folder ID
6351            * @param statuses the statuses
6352            * @param start the lower bound of the range of journal articles
6353            * @param end the upper bound of the range of journal articles (not inclusive)
6354            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6355            * @return the ordered range of matching journal articles
6356            * @throws SystemException if a system exception occurred
6357            */
6358            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6359                    long groupId, long folderId, int[] statuses, int start, int end,
6360                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6361                    throws com.liferay.portal.kernel.exception.SystemException {
6362                    return getPersistence()
6363                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
6364                            orderByComparator);
6365            }
6366    
6367            /**
6368            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
6369            *
6370            * @param groupId the group ID
6371            * @param folderId the folder ID
6372            * @param status the status
6373            * @throws SystemException if a system exception occurred
6374            */
6375            public static void removeByG_F_ST(long groupId, long folderId, int status)
6376                    throws com.liferay.portal.kernel.exception.SystemException {
6377                    getPersistence().removeByG_F_ST(groupId, folderId, status);
6378            }
6379    
6380            /**
6381            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6382            *
6383            * @param groupId the group ID
6384            * @param folderId the folder ID
6385            * @param status the status
6386            * @return the number of matching journal articles
6387            * @throws SystemException if a system exception occurred
6388            */
6389            public static int countByG_F_ST(long groupId, long folderId, int status)
6390                    throws com.liferay.portal.kernel.exception.SystemException {
6391                    return getPersistence().countByG_F_ST(groupId, folderId, status);
6392            }
6393    
6394            /**
6395            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6396            *
6397            * @param groupId the group ID
6398            * @param folderId the folder ID
6399            * @param statuses the statuses
6400            * @return the number of matching journal articles
6401            * @throws SystemException if a system exception occurred
6402            */
6403            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
6404                    throws com.liferay.portal.kernel.exception.SystemException {
6405                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
6406            }
6407    
6408            /**
6409            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6410            *
6411            * @param groupId the group ID
6412            * @param folderId the folder ID
6413            * @param status the status
6414            * @return the number of matching journal articles that the user has permission to view
6415            * @throws SystemException if a system exception occurred
6416            */
6417            public static int filterCountByG_F_ST(long groupId, long folderId,
6418                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6419                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
6420            }
6421    
6422            /**
6423            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
6424            *
6425            * @param groupId the group ID
6426            * @param folderId the folder ID
6427            * @param statuses the statuses
6428            * @return the number of matching journal articles that the user has permission to view
6429            * @throws SystemException if a system exception occurred
6430            */
6431            public static int filterCountByG_F_ST(long groupId, long folderId,
6432                    int[] statuses)
6433                    throws com.liferay.portal.kernel.exception.SystemException {
6434                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
6435            }
6436    
6437            /**
6438            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6439            *
6440            * @param groupId the group ID
6441            * @param classNameId the class name ID
6442            * @param classPK the class p k
6443            * @return the matching journal articles
6444            * @throws SystemException if a system exception occurred
6445            */
6446            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6447                    long groupId, long classNameId, long classPK)
6448                    throws com.liferay.portal.kernel.exception.SystemException {
6449                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
6450            }
6451    
6452            /**
6453            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6454            *
6455            * <p>
6456            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6457            * </p>
6458            *
6459            * @param groupId the group ID
6460            * @param classNameId the class name ID
6461            * @param classPK the class p k
6462            * @param start the lower bound of the range of journal articles
6463            * @param end the upper bound of the range of journal articles (not inclusive)
6464            * @return the range of matching journal articles
6465            * @throws SystemException if a system exception occurred
6466            */
6467            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6468                    long groupId, long classNameId, long classPK, int start, int end)
6469                    throws com.liferay.portal.kernel.exception.SystemException {
6470                    return getPersistence()
6471                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
6472            }
6473    
6474            /**
6475            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6476            *
6477            * <p>
6478            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6479            * </p>
6480            *
6481            * @param groupId the group ID
6482            * @param classNameId the class name ID
6483            * @param classPK the class p k
6484            * @param start the lower bound of the range of journal articles
6485            * @param end the upper bound of the range of journal articles (not inclusive)
6486            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6487            * @return the ordered range of matching journal articles
6488            * @throws SystemException if a system exception occurred
6489            */
6490            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6491                    long groupId, long classNameId, long classPK, int start, int end,
6492                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6493                    throws com.liferay.portal.kernel.exception.SystemException {
6494                    return getPersistence()
6495                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
6496                            orderByComparator);
6497            }
6498    
6499            /**
6500            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6501            *
6502            * @param groupId the group ID
6503            * @param classNameId the class name ID
6504            * @param classPK the class p k
6505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6506            * @return the first matching journal article
6507            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6508            * @throws SystemException if a system exception occurred
6509            */
6510            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
6511                    long groupId, long classNameId, long classPK,
6512                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6513                    throws com.liferay.portal.kernel.exception.SystemException,
6514                            com.liferay.portlet.journal.NoSuchArticleException {
6515                    return getPersistence()
6516                                       .findByG_C_C_First(groupId, classNameId, classPK,
6517                            orderByComparator);
6518            }
6519    
6520            /**
6521            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6522            *
6523            * @param groupId the group ID
6524            * @param classNameId the class name ID
6525            * @param classPK the class p k
6526            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6527            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6528            * @throws SystemException if a system exception occurred
6529            */
6530            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
6531                    long groupId, long classNameId, long classPK,
6532                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6533                    throws com.liferay.portal.kernel.exception.SystemException {
6534                    return getPersistence()
6535                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
6536                            orderByComparator);
6537            }
6538    
6539            /**
6540            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6541            *
6542            * @param groupId the group ID
6543            * @param classNameId the class name ID
6544            * @param classPK the class p k
6545            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6546            * @return the last matching journal article
6547            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6548            * @throws SystemException if a system exception occurred
6549            */
6550            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
6551                    long groupId, long classNameId, long classPK,
6552                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6553                    throws com.liferay.portal.kernel.exception.SystemException,
6554                            com.liferay.portlet.journal.NoSuchArticleException {
6555                    return getPersistence()
6556                                       .findByG_C_C_Last(groupId, classNameId, classPK,
6557                            orderByComparator);
6558            }
6559    
6560            /**
6561            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6562            *
6563            * @param groupId the group ID
6564            * @param classNameId the class name ID
6565            * @param classPK the class p k
6566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6567            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6568            * @throws SystemException if a system exception occurred
6569            */
6570            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
6571                    long groupId, long classNameId, long classPK,
6572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6573                    throws com.liferay.portal.kernel.exception.SystemException {
6574                    return getPersistence()
6575                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
6576                            orderByComparator);
6577            }
6578    
6579            /**
6580            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6581            *
6582            * @param id the primary key of the current journal article
6583            * @param groupId the group ID
6584            * @param classNameId the class name ID
6585            * @param classPK the class p k
6586            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6587            * @return the previous, current, and next journal article
6588            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6589            * @throws SystemException if a system exception occurred
6590            */
6591            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
6592                    long id, long groupId, long classNameId, long classPK,
6593                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6594                    throws com.liferay.portal.kernel.exception.SystemException,
6595                            com.liferay.portlet.journal.NoSuchArticleException {
6596                    return getPersistence()
6597                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
6598                            orderByComparator);
6599            }
6600    
6601            /**
6602            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6603            *
6604            * @param groupId the group ID
6605            * @param classNameId the class name ID
6606            * @param classPK the class p k
6607            * @return the matching journal articles that the user has permission to view
6608            * @throws SystemException if a system exception occurred
6609            */
6610            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6611                    long groupId, long classNameId, long classPK)
6612                    throws com.liferay.portal.kernel.exception.SystemException {
6613                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
6614            }
6615    
6616            /**
6617            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6618            *
6619            * <p>
6620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6621            * </p>
6622            *
6623            * @param groupId the group ID
6624            * @param classNameId the class name ID
6625            * @param classPK the class p k
6626            * @param start the lower bound of the range of journal articles
6627            * @param end the upper bound of the range of journal articles (not inclusive)
6628            * @return the range of matching journal articles that the user has permission to view
6629            * @throws SystemException if a system exception occurred
6630            */
6631            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6632                    long groupId, long classNameId, long classPK, int start, int end)
6633                    throws com.liferay.portal.kernel.exception.SystemException {
6634                    return getPersistence()
6635                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
6636            }
6637    
6638            /**
6639            * 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;.
6640            *
6641            * <p>
6642            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6643            * </p>
6644            *
6645            * @param groupId the group ID
6646            * @param classNameId the class name ID
6647            * @param classPK the class p k
6648            * @param start the lower bound of the range of journal articles
6649            * @param end the upper bound of the range of journal articles (not inclusive)
6650            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6651            * @return the ordered range of matching journal articles that the user has permission to view
6652            * @throws SystemException if a system exception occurred
6653            */
6654            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6655                    long groupId, long classNameId, long classPK, int start, int end,
6656                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6657                    throws com.liferay.portal.kernel.exception.SystemException {
6658                    return getPersistence()
6659                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
6660                            end, orderByComparator);
6661            }
6662    
6663            /**
6664            * 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;.
6665            *
6666            * @param id the primary key of the current journal article
6667            * @param groupId the group ID
6668            * @param classNameId the class name ID
6669            * @param classPK the class p k
6670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6671            * @return the previous, current, and next journal article
6672            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6673            * @throws SystemException if a system exception occurred
6674            */
6675            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
6676                    long id, long groupId, long classNameId, long classPK,
6677                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6678                    throws com.liferay.portal.kernel.exception.SystemException,
6679                            com.liferay.portlet.journal.NoSuchArticleException {
6680                    return getPersistence()
6681                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
6682                            classPK, orderByComparator);
6683            }
6684    
6685            /**
6686            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
6687            *
6688            * @param groupId the group ID
6689            * @param classNameId the class name ID
6690            * @param classPK the class p k
6691            * @throws SystemException if a system exception occurred
6692            */
6693            public static void removeByG_C_C(long groupId, long classNameId,
6694                    long classPK)
6695                    throws com.liferay.portal.kernel.exception.SystemException {
6696                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
6697            }
6698    
6699            /**
6700            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6701            *
6702            * @param groupId the group ID
6703            * @param classNameId the class name ID
6704            * @param classPK the class p k
6705            * @return the number of matching journal articles
6706            * @throws SystemException if a system exception occurred
6707            */
6708            public static int countByG_C_C(long groupId, long classNameId, long classPK)
6709                    throws com.liferay.portal.kernel.exception.SystemException {
6710                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
6711            }
6712    
6713            /**
6714            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6715            *
6716            * @param groupId the group ID
6717            * @param classNameId the class name ID
6718            * @param classPK the class p k
6719            * @return the number of matching journal articles that the user has permission to view
6720            * @throws SystemException if a system exception occurred
6721            */
6722            public static int filterCountByG_C_C(long groupId, long classNameId,
6723                    long classPK)
6724                    throws com.liferay.portal.kernel.exception.SystemException {
6725                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
6726            }
6727    
6728            /**
6729            * 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.
6730            *
6731            * @param groupId the group ID
6732            * @param classNameId the class name ID
6733            * @param structureId the structure ID
6734            * @return the matching journal article
6735            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6736            * @throws SystemException if a system exception occurred
6737            */
6738            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
6739                    long groupId, long classNameId, java.lang.String structureId)
6740                    throws com.liferay.portal.kernel.exception.SystemException,
6741                            com.liferay.portlet.journal.NoSuchArticleException {
6742                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
6743            }
6744    
6745            /**
6746            * 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.
6747            *
6748            * @param groupId the group ID
6749            * @param classNameId the class name ID
6750            * @param structureId the structure ID
6751            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6752            * @throws SystemException if a system exception occurred
6753            */
6754            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6755                    long groupId, long classNameId, java.lang.String structureId)
6756                    throws com.liferay.portal.kernel.exception.SystemException {
6757                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
6758            }
6759    
6760            /**
6761            * 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.
6762            *
6763            * @param groupId the group ID
6764            * @param classNameId the class name ID
6765            * @param structureId the structure ID
6766            * @param retrieveFromCache whether to use the finder cache
6767            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6768            * @throws SystemException if a system exception occurred
6769            */
6770            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6771                    long groupId, long classNameId, java.lang.String structureId,
6772                    boolean retrieveFromCache)
6773                    throws com.liferay.portal.kernel.exception.SystemException {
6774                    return getPersistence()
6775                                       .fetchByG_C_S(groupId, classNameId, structureId,
6776                            retrieveFromCache);
6777            }
6778    
6779            /**
6780            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
6781            *
6782            * @param groupId the group ID
6783            * @param classNameId the class name ID
6784            * @param structureId the structure ID
6785            * @return the journal article that was removed
6786            * @throws SystemException if a system exception occurred
6787            */
6788            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
6789                    long groupId, long classNameId, java.lang.String structureId)
6790                    throws com.liferay.portal.kernel.exception.SystemException,
6791                            com.liferay.portlet.journal.NoSuchArticleException {
6792                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
6793            }
6794    
6795            /**
6796            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
6797            *
6798            * @param groupId the group ID
6799            * @param classNameId the class name ID
6800            * @param structureId the structure ID
6801            * @return the number of matching journal articles
6802            * @throws SystemException if a system exception occurred
6803            */
6804            public static int countByG_C_S(long groupId, long classNameId,
6805                    java.lang.String structureId)
6806                    throws com.liferay.portal.kernel.exception.SystemException {
6807                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
6808            }
6809    
6810            /**
6811            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6812            *
6813            * @param groupId the group ID
6814            * @param classNameId the class name ID
6815            * @param templateId the template ID
6816            * @return the matching journal articles
6817            * @throws SystemException if a system exception occurred
6818            */
6819            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6820                    long groupId, long classNameId, java.lang.String templateId)
6821                    throws com.liferay.portal.kernel.exception.SystemException {
6822                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
6823            }
6824    
6825            /**
6826            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6827            *
6828            * <p>
6829            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6830            * </p>
6831            *
6832            * @param groupId the group ID
6833            * @param classNameId the class name ID
6834            * @param templateId the template ID
6835            * @param start the lower bound of the range of journal articles
6836            * @param end the upper bound of the range of journal articles (not inclusive)
6837            * @return the range of matching journal articles
6838            * @throws SystemException if a system exception occurred
6839            */
6840            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6841                    long groupId, long classNameId, java.lang.String templateId, int start,
6842                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6843                    return getPersistence()
6844                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
6845            }
6846    
6847            /**
6848            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6849            *
6850            * <p>
6851            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6852            * </p>
6853            *
6854            * @param groupId the group ID
6855            * @param classNameId the class name ID
6856            * @param templateId the template ID
6857            * @param start the lower bound of the range of journal articles
6858            * @param end the upper bound of the range of journal articles (not inclusive)
6859            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6860            * @return the ordered range of matching journal articles
6861            * @throws SystemException if a system exception occurred
6862            */
6863            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6864                    long groupId, long classNameId, java.lang.String templateId, int start,
6865                    int end,
6866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6867                    throws com.liferay.portal.kernel.exception.SystemException {
6868                    return getPersistence()
6869                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
6870                            orderByComparator);
6871            }
6872    
6873            /**
6874            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6875            *
6876            * @param groupId the group ID
6877            * @param classNameId the class name ID
6878            * @param templateId the template ID
6879            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6880            * @return the first matching journal article
6881            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6882            * @throws SystemException if a system exception occurred
6883            */
6884            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
6885                    long groupId, long classNameId, java.lang.String templateId,
6886                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6887                    throws com.liferay.portal.kernel.exception.SystemException,
6888                            com.liferay.portlet.journal.NoSuchArticleException {
6889                    return getPersistence()
6890                                       .findByG_C_T_First(groupId, classNameId, templateId,
6891                            orderByComparator);
6892            }
6893    
6894            /**
6895            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6896            *
6897            * @param groupId the group ID
6898            * @param classNameId the class name ID
6899            * @param templateId the template ID
6900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6901            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6902            * @throws SystemException if a system exception occurred
6903            */
6904            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
6905                    long groupId, long classNameId, java.lang.String templateId,
6906                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6907                    throws com.liferay.portal.kernel.exception.SystemException {
6908                    return getPersistence()
6909                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
6910                            orderByComparator);
6911            }
6912    
6913            /**
6914            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6915            *
6916            * @param groupId the group ID
6917            * @param classNameId the class name ID
6918            * @param templateId the template ID
6919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6920            * @return the last matching journal article
6921            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6922            * @throws SystemException if a system exception occurred
6923            */
6924            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
6925                    long groupId, long classNameId, java.lang.String templateId,
6926                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6927                    throws com.liferay.portal.kernel.exception.SystemException,
6928                            com.liferay.portlet.journal.NoSuchArticleException {
6929                    return getPersistence()
6930                                       .findByG_C_T_Last(groupId, classNameId, templateId,
6931                            orderByComparator);
6932            }
6933    
6934            /**
6935            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6936            *
6937            * @param groupId the group ID
6938            * @param classNameId the class name ID
6939            * @param templateId the template ID
6940            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6941            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6942            * @throws SystemException if a system exception occurred
6943            */
6944            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
6945                    long groupId, long classNameId, java.lang.String templateId,
6946                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6947                    throws com.liferay.portal.kernel.exception.SystemException {
6948                    return getPersistence()
6949                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
6950                            orderByComparator);
6951            }
6952    
6953            /**
6954            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6955            *
6956            * @param id the primary key of the current journal article
6957            * @param groupId the group ID
6958            * @param classNameId the class name ID
6959            * @param templateId the template ID
6960            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6961            * @return the previous, current, and next journal article
6962            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6963            * @throws SystemException if a system exception occurred
6964            */
6965            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
6966                    long id, long groupId, long classNameId, java.lang.String templateId,
6967                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6968                    throws com.liferay.portal.kernel.exception.SystemException,
6969                            com.liferay.portlet.journal.NoSuchArticleException {
6970                    return getPersistence()
6971                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
6972                            templateId, orderByComparator);
6973            }
6974    
6975            /**
6976            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6977            *
6978            * @param groupId the group ID
6979            * @param classNameId the class name ID
6980            * @param templateId the template ID
6981            * @return the matching journal articles that the user has permission to view
6982            * @throws SystemException if a system exception occurred
6983            */
6984            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6985                    long groupId, long classNameId, java.lang.String templateId)
6986                    throws com.liferay.portal.kernel.exception.SystemException {
6987                    return getPersistence()
6988                                       .filterFindByG_C_T(groupId, classNameId, templateId);
6989            }
6990    
6991            /**
6992            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6993            *
6994            * <p>
6995            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6996            * </p>
6997            *
6998            * @param groupId the group ID
6999            * @param classNameId the class name ID
7000            * @param templateId the template ID
7001            * @param start the lower bound of the range of journal articles
7002            * @param end the upper bound of the range of journal articles (not inclusive)
7003            * @return the range of matching journal articles that the user has permission to view
7004            * @throws SystemException if a system exception occurred
7005            */
7006            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
7007                    long groupId, long classNameId, java.lang.String templateId, int start,
7008                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7009                    return getPersistence()
7010                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
7011                            end);
7012            }
7013    
7014            /**
7015            * 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;.
7016            *
7017            * <p>
7018            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7019            * </p>
7020            *
7021            * @param groupId the group ID
7022            * @param classNameId the class name ID
7023            * @param templateId the template ID
7024            * @param start the lower bound of the range of journal articles
7025            * @param end the upper bound of the range of journal articles (not inclusive)
7026            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7027            * @return the ordered range of matching journal articles that the user has permission to view
7028            * @throws SystemException if a system exception occurred
7029            */
7030            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
7031                    long groupId, long classNameId, java.lang.String templateId, int start,
7032                    int end,
7033                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7034                    throws com.liferay.portal.kernel.exception.SystemException {
7035                    return getPersistence()
7036                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
7037                            end, orderByComparator);
7038            }
7039    
7040            /**
7041            * 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;.
7042            *
7043            * @param id the primary key of the current journal article
7044            * @param groupId the group ID
7045            * @param classNameId the class name ID
7046            * @param templateId the template ID
7047            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7048            * @return the previous, current, and next journal article
7049            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7050            * @throws SystemException if a system exception occurred
7051            */
7052            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
7053                    long id, long groupId, long classNameId, java.lang.String templateId,
7054                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7055                    throws com.liferay.portal.kernel.exception.SystemException,
7056                            com.liferay.portlet.journal.NoSuchArticleException {
7057                    return getPersistence()
7058                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
7059                            templateId, orderByComparator);
7060            }
7061    
7062            /**
7063            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
7064            *
7065            * @param groupId the group ID
7066            * @param classNameId the class name ID
7067            * @param templateId the template ID
7068            * @throws SystemException if a system exception occurred
7069            */
7070            public static void removeByG_C_T(long groupId, long classNameId,
7071                    java.lang.String templateId)
7072                    throws com.liferay.portal.kernel.exception.SystemException {
7073                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
7074            }
7075    
7076            /**
7077            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7078            *
7079            * @param groupId the group ID
7080            * @param classNameId the class name ID
7081            * @param templateId the template ID
7082            * @return the number of matching journal articles
7083            * @throws SystemException if a system exception occurred
7084            */
7085            public static int countByG_C_T(long groupId, long classNameId,
7086                    java.lang.String templateId)
7087                    throws com.liferay.portal.kernel.exception.SystemException {
7088                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
7089            }
7090    
7091            /**
7092            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7093            *
7094            * @param groupId the group ID
7095            * @param classNameId the class name ID
7096            * @param templateId the template ID
7097            * @return the number of matching journal articles that the user has permission to view
7098            * @throws SystemException if a system exception occurred
7099            */
7100            public static int filterCountByG_C_T(long groupId, long classNameId,
7101                    java.lang.String templateId)
7102                    throws com.liferay.portal.kernel.exception.SystemException {
7103                    return getPersistence()
7104                                       .filterCountByG_C_T(groupId, classNameId, templateId);
7105            }
7106    
7107            /**
7108            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7109            *
7110            * @param groupId the group ID
7111            * @param classNameId the class name ID
7112            * @param layoutUuid the layout uuid
7113            * @return the matching journal articles
7114            * @throws SystemException if a system exception occurred
7115            */
7116            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
7117                    long groupId, long classNameId, java.lang.String layoutUuid)
7118                    throws com.liferay.portal.kernel.exception.SystemException {
7119                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
7120            }
7121    
7122            /**
7123            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7124            *
7125            * <p>
7126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7127            * </p>
7128            *
7129            * @param groupId the group ID
7130            * @param classNameId the class name ID
7131            * @param layoutUuid the layout uuid
7132            * @param start the lower bound of the range of journal articles
7133            * @param end the upper bound of the range of journal articles (not inclusive)
7134            * @return the range of matching journal articles
7135            * @throws SystemException if a system exception occurred
7136            */
7137            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
7138                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7139                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7140                    return getPersistence()
7141                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
7142            }
7143    
7144            /**
7145            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7146            *
7147            * <p>
7148            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7149            * </p>
7150            *
7151            * @param groupId the group ID
7152            * @param classNameId the class name ID
7153            * @param layoutUuid the layout uuid
7154            * @param start the lower bound of the range of journal articles
7155            * @param end the upper bound of the range of journal articles (not inclusive)
7156            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7157            * @return the ordered range of matching journal articles
7158            * @throws SystemException if a system exception occurred
7159            */
7160            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
7161                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7162                    int end,
7163                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7164                    throws com.liferay.portal.kernel.exception.SystemException {
7165                    return getPersistence()
7166                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
7167                            orderByComparator);
7168            }
7169    
7170            /**
7171            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7172            *
7173            * @param groupId the group ID
7174            * @param classNameId the class name ID
7175            * @param layoutUuid the layout uuid
7176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7177            * @return the first matching journal article
7178            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7179            * @throws SystemException if a system exception occurred
7180            */
7181            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
7182                    long groupId, long classNameId, java.lang.String layoutUuid,
7183                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7184                    throws com.liferay.portal.kernel.exception.SystemException,
7185                            com.liferay.portlet.journal.NoSuchArticleException {
7186                    return getPersistence()
7187                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
7188                            orderByComparator);
7189            }
7190    
7191            /**
7192            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7193            *
7194            * @param groupId the group ID
7195            * @param classNameId the class name ID
7196            * @param layoutUuid the layout uuid
7197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7198            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7199            * @throws SystemException if a system exception occurred
7200            */
7201            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
7202                    long groupId, long classNameId, java.lang.String layoutUuid,
7203                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7204                    throws com.liferay.portal.kernel.exception.SystemException {
7205                    return getPersistence()
7206                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
7207                            orderByComparator);
7208            }
7209    
7210            /**
7211            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7212            *
7213            * @param groupId the group ID
7214            * @param classNameId the class name ID
7215            * @param layoutUuid the layout uuid
7216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7217            * @return the last matching journal article
7218            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7219            * @throws SystemException if a system exception occurred
7220            */
7221            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
7222                    long groupId, long classNameId, java.lang.String layoutUuid,
7223                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7224                    throws com.liferay.portal.kernel.exception.SystemException,
7225                            com.liferay.portlet.journal.NoSuchArticleException {
7226                    return getPersistence()
7227                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
7228                            orderByComparator);
7229            }
7230    
7231            /**
7232            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7233            *
7234            * @param groupId the group ID
7235            * @param classNameId the class name ID
7236            * @param layoutUuid the layout uuid
7237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7238            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7239            * @throws SystemException if a system exception occurred
7240            */
7241            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
7242                    long groupId, long classNameId, java.lang.String layoutUuid,
7243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7244                    throws com.liferay.portal.kernel.exception.SystemException {
7245                    return getPersistence()
7246                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
7247                            orderByComparator);
7248            }
7249    
7250            /**
7251            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7252            *
7253            * @param id the primary key of the current journal article
7254            * @param groupId the group ID
7255            * @param classNameId the class name ID
7256            * @param layoutUuid the layout uuid
7257            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7258            * @return the previous, current, and next journal article
7259            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7260            * @throws SystemException if a system exception occurred
7261            */
7262            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
7263                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
7264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7265                    throws com.liferay.portal.kernel.exception.SystemException,
7266                            com.liferay.portlet.journal.NoSuchArticleException {
7267                    return getPersistence()
7268                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
7269                            layoutUuid, orderByComparator);
7270            }
7271    
7272            /**
7273            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7274            *
7275            * @param groupId the group ID
7276            * @param classNameId the class name ID
7277            * @param layoutUuid the layout uuid
7278            * @return the matching journal articles that the user has permission to view
7279            * @throws SystemException if a system exception occurred
7280            */
7281            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7282                    long groupId, long classNameId, java.lang.String layoutUuid)
7283                    throws com.liferay.portal.kernel.exception.SystemException {
7284                    return getPersistence()
7285                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
7286            }
7287    
7288            /**
7289            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7290            *
7291            * <p>
7292            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7293            * </p>
7294            *
7295            * @param groupId the group ID
7296            * @param classNameId the class name ID
7297            * @param layoutUuid the layout uuid
7298            * @param start the lower bound of the range of journal articles
7299            * @param end the upper bound of the range of journal articles (not inclusive)
7300            * @return the range of matching journal articles that the user has permission to view
7301            * @throws SystemException if a system exception occurred
7302            */
7303            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7304                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7305                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7306                    return getPersistence()
7307                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
7308                            end);
7309            }
7310    
7311            /**
7312            * 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;.
7313            *
7314            * <p>
7315            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7316            * </p>
7317            *
7318            * @param groupId the group ID
7319            * @param classNameId the class name ID
7320            * @param layoutUuid the layout uuid
7321            * @param start the lower bound of the range of journal articles
7322            * @param end the upper bound of the range of journal articles (not inclusive)
7323            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7324            * @return the ordered range of matching journal articles that the user has permission to view
7325            * @throws SystemException if a system exception occurred
7326            */
7327            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7328                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7329                    int end,
7330                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7331                    throws com.liferay.portal.kernel.exception.SystemException {
7332                    return getPersistence()
7333                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
7334                            end, orderByComparator);
7335            }
7336    
7337            /**
7338            * 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;.
7339            *
7340            * @param id the primary key of the current journal article
7341            * @param groupId the group ID
7342            * @param classNameId the class name ID
7343            * @param layoutUuid the layout uuid
7344            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7345            * @return the previous, current, and next journal article
7346            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7347            * @throws SystemException if a system exception occurred
7348            */
7349            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
7350                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
7351                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7352                    throws com.liferay.portal.kernel.exception.SystemException,
7353                            com.liferay.portlet.journal.NoSuchArticleException {
7354                    return getPersistence()
7355                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
7356                            layoutUuid, orderByComparator);
7357            }
7358    
7359            /**
7360            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
7361            *
7362            * @param groupId the group ID
7363            * @param classNameId the class name ID
7364            * @param layoutUuid the layout uuid
7365            * @throws SystemException if a system exception occurred
7366            */
7367            public static void removeByG_C_L(long groupId, long classNameId,
7368                    java.lang.String layoutUuid)
7369                    throws com.liferay.portal.kernel.exception.SystemException {
7370                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
7371            }
7372    
7373            /**
7374            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7375            *
7376            * @param groupId the group ID
7377            * @param classNameId the class name ID
7378            * @param layoutUuid the layout uuid
7379            * @return the number of matching journal articles
7380            * @throws SystemException if a system exception occurred
7381            */
7382            public static int countByG_C_L(long groupId, long classNameId,
7383                    java.lang.String layoutUuid)
7384                    throws com.liferay.portal.kernel.exception.SystemException {
7385                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
7386            }
7387    
7388            /**
7389            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7390            *
7391            * @param groupId the group ID
7392            * @param classNameId the class name ID
7393            * @param layoutUuid the layout uuid
7394            * @return the number of matching journal articles that the user has permission to view
7395            * @throws SystemException if a system exception occurred
7396            */
7397            public static int filterCountByG_C_L(long groupId, long classNameId,
7398                    java.lang.String layoutUuid)
7399                    throws com.liferay.portal.kernel.exception.SystemException {
7400                    return getPersistence()
7401                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
7402            }
7403    
7404            /**
7405            * 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.
7406            *
7407            * @param groupId the group ID
7408            * @param articleId the article ID
7409            * @param version the version
7410            * @return the matching journal article
7411            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7412            * @throws SystemException if a system exception occurred
7413            */
7414            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
7415                    long groupId, java.lang.String articleId, double version)
7416                    throws com.liferay.portal.kernel.exception.SystemException,
7417                            com.liferay.portlet.journal.NoSuchArticleException {
7418                    return getPersistence().findByG_A_V(groupId, articleId, version);
7419            }
7420    
7421            /**
7422            * 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.
7423            *
7424            * @param groupId the group ID
7425            * @param articleId the article ID
7426            * @param version the version
7427            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7428            * @throws SystemException if a system exception occurred
7429            */
7430            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7431                    long groupId, java.lang.String articleId, double version)
7432                    throws com.liferay.portal.kernel.exception.SystemException {
7433                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
7434            }
7435    
7436            /**
7437            * 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.
7438            *
7439            * @param groupId the group ID
7440            * @param articleId the article ID
7441            * @param version the version
7442            * @param retrieveFromCache whether to use the finder cache
7443            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7444            * @throws SystemException if a system exception occurred
7445            */
7446            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7447                    long groupId, java.lang.String articleId, double version,
7448                    boolean retrieveFromCache)
7449                    throws com.liferay.portal.kernel.exception.SystemException {
7450                    return getPersistence()
7451                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
7452            }
7453    
7454            /**
7455            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
7456            *
7457            * @param groupId the group ID
7458            * @param articleId the article ID
7459            * @param version the version
7460            * @return the journal article that was removed
7461            * @throws SystemException if a system exception occurred
7462            */
7463            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
7464                    long groupId, java.lang.String articleId, double version)
7465                    throws com.liferay.portal.kernel.exception.SystemException,
7466                            com.liferay.portlet.journal.NoSuchArticleException {
7467                    return getPersistence().removeByG_A_V(groupId, articleId, version);
7468            }
7469    
7470            /**
7471            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
7472            *
7473            * @param groupId the group ID
7474            * @param articleId the article ID
7475            * @param version the version
7476            * @return the number of matching journal articles
7477            * @throws SystemException if a system exception occurred
7478            */
7479            public static int countByG_A_V(long groupId, java.lang.String articleId,
7480                    double version)
7481                    throws com.liferay.portal.kernel.exception.SystemException {
7482                    return getPersistence().countByG_A_V(groupId, articleId, version);
7483            }
7484    
7485            /**
7486            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7487            *
7488            * @param groupId the group ID
7489            * @param articleId the article ID
7490            * @param status the status
7491            * @return the matching journal articles
7492            * @throws SystemException if a system exception occurred
7493            */
7494            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7495                    long groupId, java.lang.String articleId, int status)
7496                    throws com.liferay.portal.kernel.exception.SystemException {
7497                    return getPersistence().findByG_A_ST(groupId, articleId, status);
7498            }
7499    
7500            /**
7501            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7502            *
7503            * <p>
7504            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7505            * </p>
7506            *
7507            * @param groupId the group ID
7508            * @param articleId the article ID
7509            * @param status the status
7510            * @param start the lower bound of the range of journal articles
7511            * @param end the upper bound of the range of journal articles (not inclusive)
7512            * @return the range of matching journal articles
7513            * @throws SystemException if a system exception occurred
7514            */
7515            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7516                    long groupId, java.lang.String articleId, int status, int start, int end)
7517                    throws com.liferay.portal.kernel.exception.SystemException {
7518                    return getPersistence()
7519                                       .findByG_A_ST(groupId, articleId, status, start, end);
7520            }
7521    
7522            /**
7523            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7524            *
7525            * <p>
7526            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7527            * </p>
7528            *
7529            * @param groupId the group ID
7530            * @param articleId the article ID
7531            * @param status the status
7532            * @param start the lower bound of the range of journal articles
7533            * @param end the upper bound of the range of journal articles (not inclusive)
7534            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7535            * @return the ordered range of matching journal articles
7536            * @throws SystemException if a system exception occurred
7537            */
7538            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7539                    long groupId, java.lang.String articleId, int status, int start,
7540                    int end,
7541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7542                    throws com.liferay.portal.kernel.exception.SystemException {
7543                    return getPersistence()
7544                                       .findByG_A_ST(groupId, articleId, status, start, end,
7545                            orderByComparator);
7546            }
7547    
7548            /**
7549            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7550            *
7551            * @param groupId the group ID
7552            * @param articleId the article ID
7553            * @param status the status
7554            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7555            * @return the first matching journal article
7556            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7557            * @throws SystemException if a system exception occurred
7558            */
7559            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
7560                    long groupId, java.lang.String articleId, int status,
7561                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7562                    throws com.liferay.portal.kernel.exception.SystemException,
7563                            com.liferay.portlet.journal.NoSuchArticleException {
7564                    return getPersistence()
7565                                       .findByG_A_ST_First(groupId, articleId, status,
7566                            orderByComparator);
7567            }
7568    
7569            /**
7570            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7571            *
7572            * @param groupId the group ID
7573            * @param articleId the article ID
7574            * @param status the status
7575            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7576            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7577            * @throws SystemException if a system exception occurred
7578            */
7579            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
7580                    long groupId, java.lang.String articleId, int status,
7581                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7582                    throws com.liferay.portal.kernel.exception.SystemException {
7583                    return getPersistence()
7584                                       .fetchByG_A_ST_First(groupId, articleId, status,
7585                            orderByComparator);
7586            }
7587    
7588            /**
7589            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7590            *
7591            * @param groupId the group ID
7592            * @param articleId the article ID
7593            * @param status the status
7594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7595            * @return the last matching journal article
7596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7597            * @throws SystemException if a system exception occurred
7598            */
7599            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
7600                    long groupId, java.lang.String articleId, int status,
7601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7602                    throws com.liferay.portal.kernel.exception.SystemException,
7603                            com.liferay.portlet.journal.NoSuchArticleException {
7604                    return getPersistence()
7605                                       .findByG_A_ST_Last(groupId, articleId, status,
7606                            orderByComparator);
7607            }
7608    
7609            /**
7610            * Returns the last journal article in the ordered set where groupId = &#63; and articleId =