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 displayDate &lt; &#63; and status = &#63;.
5076            *
5077            * @param displayDate the display date
5078            * @param status the status
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> findByLtD_S(
5083                    java.util.Date displayDate, int status)
5084                    throws com.liferay.portal.kernel.exception.SystemException {
5085                    return getPersistence().findByLtD_S(displayDate, status);
5086            }
5087    
5088            /**
5089            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#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 displayDate the display date
5096            * @param status the status
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> findByLtD_S(
5103                    java.util.Date displayDate, int status, int start, int end)
5104                    throws com.liferay.portal.kernel.exception.SystemException {
5105                    return getPersistence().findByLtD_S(displayDate, status, start, end);
5106            }
5107    
5108            /**
5109            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#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 displayDate the display date
5116            * @param status the status
5117            * @param start the lower bound of the range of journal articles
5118            * @param end the upper bound of the range of journal articles (not inclusive)
5119            * @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> findByLtD_S(
5124                    java.util.Date displayDate, int status, int start, int end,
5125                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5126                    throws com.liferay.portal.kernel.exception.SystemException {
5127                    return getPersistence()
5128                                       .findByLtD_S(displayDate, status, start, end,
5129                            orderByComparator);
5130            }
5131    
5132            /**
5133            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5134            *
5135            * @param displayDate the display date
5136            * @param status the status
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 findByLtD_S_First(
5143                    java.util.Date displayDate, int status,
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                                       .findByLtD_S_First(displayDate, status, orderByComparator);
5149            }
5150    
5151            /**
5152            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5153            *
5154            * @param displayDate the display date
5155            * @param status the status
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 fetchByLtD_S_First(
5161                    java.util.Date displayDate, int status,
5162                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5163                    throws com.liferay.portal.kernel.exception.SystemException {
5164                    return getPersistence()
5165                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
5166            }
5167    
5168            /**
5169            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5170            *
5171            * @param displayDate the display date
5172            * @param status the status
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 findByLtD_S_Last(
5179                    java.util.Date displayDate, int status,
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                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
5185            }
5186    
5187            /**
5188            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5189            *
5190            * @param displayDate the display date
5191            * @param status the status
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 fetchByLtD_S_Last(
5197                    java.util.Date displayDate, int status,
5198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5199                    throws com.liferay.portal.kernel.exception.SystemException {
5200                    return getPersistence()
5201                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
5202            }
5203    
5204            /**
5205            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5206            *
5207            * @param id the primary key of the current journal article
5208            * @param displayDate the display date
5209            * @param status the status
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[] findByLtD_S_PrevAndNext(
5216                    long id, java.util.Date displayDate, int status,
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                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
5222                            orderByComparator);
5223            }
5224    
5225            /**
5226            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
5227            *
5228            * @param displayDate the display date
5229            * @param status the status
5230            * @throws SystemException if a system exception occurred
5231            */
5232            public static void removeByLtD_S(java.util.Date displayDate, int status)
5233                    throws com.liferay.portal.kernel.exception.SystemException {
5234                    getPersistence().removeByLtD_S(displayDate, status);
5235            }
5236    
5237            /**
5238            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
5239            *
5240            * @param displayDate the display date
5241            * @param status the status
5242            * @return the number of matching journal articles
5243            * @throws SystemException if a system exception occurred
5244            */
5245            public static int countByLtD_S(java.util.Date displayDate, int status)
5246                    throws com.liferay.portal.kernel.exception.SystemException {
5247                    return getPersistence().countByLtD_S(displayDate, status);
5248            }
5249    
5250            /**
5251            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5252            *
5253            * @param resourcePrimKey the resource prim key
5254            * @param indexable the indexable
5255            * @param status the status
5256            * @return the matching journal articles
5257            * @throws SystemException if a system exception occurred
5258            */
5259            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5260                    long resourcePrimKey, boolean indexable, int status)
5261                    throws com.liferay.portal.kernel.exception.SystemException {
5262                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
5263            }
5264    
5265            /**
5266            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5267            *
5268            * <p>
5269            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5270            * </p>
5271            *
5272            * @param resourcePrimKey the resource prim key
5273            * @param indexable the indexable
5274            * @param status the status
5275            * @param start the lower bound of the range of journal articles
5276            * @param end the upper bound of the range of journal articles (not inclusive)
5277            * @return the range of matching journal articles
5278            * @throws SystemException if a system exception occurred
5279            */
5280            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5281                    long resourcePrimKey, boolean indexable, int status, int start, int end)
5282                    throws com.liferay.portal.kernel.exception.SystemException {
5283                    return getPersistence()
5284                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
5285            }
5286    
5287            /**
5288            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5289            *
5290            * <p>
5291            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5292            * </p>
5293            *
5294            * @param resourcePrimKey the resource prim key
5295            * @param indexable the indexable
5296            * @param status the status
5297            * @param start the lower bound of the range of journal articles
5298            * @param end the upper bound of the range of journal articles (not inclusive)
5299            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5300            * @return the ordered range of matching journal articles
5301            * @throws SystemException if a system exception occurred
5302            */
5303            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5304                    long resourcePrimKey, boolean indexable, int status, int start,
5305                    int end,
5306                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5307                    throws com.liferay.portal.kernel.exception.SystemException {
5308                    return getPersistence()
5309                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
5310                            orderByComparator);
5311            }
5312    
5313            /**
5314            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5315            *
5316            * @param resourcePrimKey the resource prim key
5317            * @param indexable the indexable
5318            * @param status the status
5319            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5320            * @return the first matching journal article
5321            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5322            * @throws SystemException if a system exception occurred
5323            */
5324            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First(
5325                    long resourcePrimKey, boolean indexable, int status,
5326                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5327                    throws com.liferay.portal.kernel.exception.SystemException,
5328                            com.liferay.portlet.journal.NoSuchArticleException {
5329                    return getPersistence()
5330                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
5331                            orderByComparator);
5332            }
5333    
5334            /**
5335            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5336            *
5337            * @param resourcePrimKey the resource prim key
5338            * @param indexable the indexable
5339            * @param status the status
5340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5341            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5342            * @throws SystemException if a system exception occurred
5343            */
5344            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First(
5345                    long resourcePrimKey, boolean indexable, int status,
5346                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5347                    throws com.liferay.portal.kernel.exception.SystemException {
5348                    return getPersistence()
5349                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
5350                            orderByComparator);
5351            }
5352    
5353            /**
5354            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5355            *
5356            * @param resourcePrimKey the resource prim key
5357            * @param indexable the indexable
5358            * @param status the status
5359            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5360            * @return the last matching journal article
5361            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5362            * @throws SystemException if a system exception occurred
5363            */
5364            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last(
5365                    long resourcePrimKey, boolean indexable, int status,
5366                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5367                    throws com.liferay.portal.kernel.exception.SystemException,
5368                            com.liferay.portlet.journal.NoSuchArticleException {
5369                    return getPersistence()
5370                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
5371                            orderByComparator);
5372            }
5373    
5374            /**
5375            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5376            *
5377            * @param resourcePrimKey the resource prim key
5378            * @param indexable the indexable
5379            * @param status the status
5380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5381            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5382            * @throws SystemException if a system exception occurred
5383            */
5384            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last(
5385                    long resourcePrimKey, boolean indexable, int status,
5386                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5387                    throws com.liferay.portal.kernel.exception.SystemException {
5388                    return getPersistence()
5389                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
5390                            orderByComparator);
5391            }
5392    
5393            /**
5394            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5395            *
5396            * @param id the primary key of the current journal article
5397            * @param resourcePrimKey the resource prim key
5398            * @param indexable the indexable
5399            * @param status the status
5400            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5401            * @return the previous, current, and next journal article
5402            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5403            * @throws SystemException if a system exception occurred
5404            */
5405            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext(
5406                    long id, long resourcePrimKey, boolean indexable, int status,
5407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5408                    throws com.liferay.portal.kernel.exception.SystemException,
5409                            com.liferay.portlet.journal.NoSuchArticleException {
5410                    return getPersistence()
5411                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
5412                            status, orderByComparator);
5413            }
5414    
5415            /**
5416            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5417            *
5418            * <p>
5419            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5420            * </p>
5421            *
5422            * @param resourcePrimKey the resource prim key
5423            * @param indexable the indexable
5424            * @param statuses the statuses
5425            * @return the matching journal articles
5426            * @throws SystemException if a system exception occurred
5427            */
5428            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5429                    long resourcePrimKey, boolean indexable, int[] statuses)
5430                    throws com.liferay.portal.kernel.exception.SystemException {
5431                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
5432            }
5433    
5434            /**
5435            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5436            *
5437            * <p>
5438            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5439            * </p>
5440            *
5441            * @param resourcePrimKey the resource prim key
5442            * @param indexable the indexable
5443            * @param statuses the statuses
5444            * @param start the lower bound of the range of journal articles
5445            * @param end the upper bound of the range of journal articles (not inclusive)
5446            * @return the range of matching journal articles
5447            * @throws SystemException if a system exception occurred
5448            */
5449            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5450                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5451                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5452                    return getPersistence()
5453                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
5454            }
5455    
5456            /**
5457            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5458            *
5459            * <p>
5460            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5461            * </p>
5462            *
5463            * @param resourcePrimKey the resource prim key
5464            * @param indexable the indexable
5465            * @param statuses the statuses
5466            * @param start the lower bound of the range of journal articles
5467            * @param end the upper bound of the range of journal articles (not inclusive)
5468            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5469            * @return the ordered range of matching journal articles
5470            * @throws SystemException if a system exception occurred
5471            */
5472            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5473                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5474                    int end,
5475                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5476                    throws com.liferay.portal.kernel.exception.SystemException {
5477                    return getPersistence()
5478                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
5479                            end, orderByComparator);
5480            }
5481    
5482            /**
5483            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
5484            *
5485            * @param resourcePrimKey the resource prim key
5486            * @param indexable the indexable
5487            * @param status the status
5488            * @throws SystemException if a system exception occurred
5489            */
5490            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
5491                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5492                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
5493            }
5494    
5495            /**
5496            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5497            *
5498            * @param resourcePrimKey the resource prim key
5499            * @param indexable the indexable
5500            * @param status the status
5501            * @return the number of matching journal articles
5502            * @throws SystemException if a system exception occurred
5503            */
5504            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5505                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5506                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
5507            }
5508    
5509            /**
5510            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5511            *
5512            * @param resourcePrimKey the resource prim key
5513            * @param indexable the indexable
5514            * @param statuses the statuses
5515            * @return the number of matching journal articles
5516            * @throws SystemException if a system exception occurred
5517            */
5518            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5519                    int[] statuses)
5520                    throws com.liferay.portal.kernel.exception.SystemException {
5521                    return getPersistence()
5522                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
5523            }
5524    
5525            /**
5526            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5527            *
5528            * @param groupId the group ID
5529            * @param userId the user ID
5530            * @param classNameId the class name ID
5531            * @return the matching journal articles
5532            * @throws SystemException if a system exception occurred
5533            */
5534            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5535                    long groupId, long userId, long classNameId)
5536                    throws com.liferay.portal.kernel.exception.SystemException {
5537                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
5538            }
5539    
5540            /**
5541            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5542            *
5543            * <p>
5544            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5545            * </p>
5546            *
5547            * @param groupId the group ID
5548            * @param userId the user ID
5549            * @param classNameId the class name ID
5550            * @param start the lower bound of the range of journal articles
5551            * @param end the upper bound of the range of journal articles (not inclusive)
5552            * @return the range of matching journal articles
5553            * @throws SystemException if a system exception occurred
5554            */
5555            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5556                    long groupId, long userId, long classNameId, int start, int end)
5557                    throws com.liferay.portal.kernel.exception.SystemException {
5558                    return getPersistence()
5559                                       .findByG_U_C(groupId, userId, classNameId, start, end);
5560            }
5561    
5562            /**
5563            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5564            *
5565            * <p>
5566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5567            * </p>
5568            *
5569            * @param groupId the group ID
5570            * @param userId the user ID
5571            * @param classNameId the class name ID
5572            * @param start the lower bound of the range of journal articles
5573            * @param end the upper bound of the range of journal articles (not inclusive)
5574            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5575            * @return the ordered range of matching journal articles
5576            * @throws SystemException if a system exception occurred
5577            */
5578            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5579                    long groupId, long userId, long classNameId, int start, int end,
5580                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5581                    throws com.liferay.portal.kernel.exception.SystemException {
5582                    return getPersistence()
5583                                       .findByG_U_C(groupId, userId, classNameId, start, end,
5584                            orderByComparator);
5585            }
5586    
5587            /**
5588            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5589            *
5590            * @param groupId the group ID
5591            * @param userId the user ID
5592            * @param classNameId the class name ID
5593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5594            * @return the first matching journal article
5595            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5596            * @throws SystemException if a system exception occurred
5597            */
5598            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
5599                    long groupId, long userId, long classNameId,
5600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5601                    throws com.liferay.portal.kernel.exception.SystemException,
5602                            com.liferay.portlet.journal.NoSuchArticleException {
5603                    return getPersistence()
5604                                       .findByG_U_C_First(groupId, userId, classNameId,
5605                            orderByComparator);
5606            }
5607    
5608            /**
5609            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5610            *
5611            * @param groupId the group ID
5612            * @param userId the user ID
5613            * @param classNameId the class name ID
5614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5615            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5616            * @throws SystemException if a system exception occurred
5617            */
5618            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
5619                    long groupId, long userId, long classNameId,
5620                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5621                    throws com.liferay.portal.kernel.exception.SystemException {
5622                    return getPersistence()
5623                                       .fetchByG_U_C_First(groupId, userId, classNameId,
5624                            orderByComparator);
5625            }
5626    
5627            /**
5628            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5629            *
5630            * @param groupId the group ID
5631            * @param userId the user ID
5632            * @param classNameId the class name ID
5633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5634            * @return the last matching journal article
5635            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5636            * @throws SystemException if a system exception occurred
5637            */
5638            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
5639                    long groupId, long userId, long classNameId,
5640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5641                    throws com.liferay.portal.kernel.exception.SystemException,
5642                            com.liferay.portlet.journal.NoSuchArticleException {
5643                    return getPersistence()
5644                                       .findByG_U_C_Last(groupId, userId, classNameId,
5645                            orderByComparator);
5646            }
5647    
5648            /**
5649            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5650            *
5651            * @param groupId the group ID
5652            * @param userId the user ID
5653            * @param classNameId the class name ID
5654            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5655            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5656            * @throws SystemException if a system exception occurred
5657            */
5658            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
5659                    long groupId, long userId, long classNameId,
5660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5661                    throws com.liferay.portal.kernel.exception.SystemException {
5662                    return getPersistence()
5663                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
5664                            orderByComparator);
5665            }
5666    
5667            /**
5668            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5669            *
5670            * @param id the primary key of the current journal article
5671            * @param groupId the group ID
5672            * @param userId the user ID
5673            * @param classNameId the class name ID
5674            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5675            * @return the previous, current, and next journal article
5676            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5677            * @throws SystemException if a system exception occurred
5678            */
5679            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
5680                    long id, long groupId, long userId, long classNameId,
5681                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5682                    throws com.liferay.portal.kernel.exception.SystemException,
5683                            com.liferay.portlet.journal.NoSuchArticleException {
5684                    return getPersistence()
5685                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
5686                            orderByComparator);
5687            }
5688    
5689            /**
5690            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5691            *
5692            * @param groupId the group ID
5693            * @param userId the user ID
5694            * @param classNameId the class name ID
5695            * @return the matching journal articles that the user has permission to view
5696            * @throws SystemException if a system exception occurred
5697            */
5698            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5699                    long groupId, long userId, long classNameId)
5700                    throws com.liferay.portal.kernel.exception.SystemException {
5701                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
5702            }
5703    
5704            /**
5705            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5706            *
5707            * <p>
5708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5709            * </p>
5710            *
5711            * @param groupId the group ID
5712            * @param userId the user ID
5713            * @param classNameId the class name ID
5714            * @param start the lower bound of the range of journal articles
5715            * @param end the upper bound of the range of journal articles (not inclusive)
5716            * @return the range of matching journal articles that the user has permission to view
5717            * @throws SystemException if a system exception occurred
5718            */
5719            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5720                    long groupId, long userId, long classNameId, int start, int end)
5721                    throws com.liferay.portal.kernel.exception.SystemException {
5722                    return getPersistence()
5723                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
5724            }
5725    
5726            /**
5727            * 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;.
5728            *
5729            * <p>
5730            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5731            * </p>
5732            *
5733            * @param groupId the group ID
5734            * @param userId the user ID
5735            * @param classNameId the class name ID
5736            * @param start the lower bound of the range of journal articles
5737            * @param end the upper bound of the range of journal articles (not inclusive)
5738            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5739            * @return the ordered range of matching journal articles that the user has permission to view
5740            * @throws SystemException if a system exception occurred
5741            */
5742            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5743                    long groupId, long userId, long classNameId, int start, int end,
5744                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5745                    throws com.liferay.portal.kernel.exception.SystemException {
5746                    return getPersistence()
5747                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
5748                            orderByComparator);
5749            }
5750    
5751            /**
5752            * 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;.
5753            *
5754            * @param id the primary key of the current journal article
5755            * @param groupId the group ID
5756            * @param userId the user ID
5757            * @param classNameId the class name ID
5758            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5759            * @return the previous, current, and next journal article
5760            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5761            * @throws SystemException if a system exception occurred
5762            */
5763            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
5764                    long id, long groupId, long userId, long classNameId,
5765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5766                    throws com.liferay.portal.kernel.exception.SystemException,
5767                            com.liferay.portlet.journal.NoSuchArticleException {
5768                    return getPersistence()
5769                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
5770                            classNameId, orderByComparator);
5771            }
5772    
5773            /**
5774            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
5775            *
5776            * @param groupId the group ID
5777            * @param userId the user ID
5778            * @param classNameId the class name ID
5779            * @throws SystemException if a system exception occurred
5780            */
5781            public static void removeByG_U_C(long groupId, long userId, long classNameId)
5782                    throws com.liferay.portal.kernel.exception.SystemException {
5783                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
5784            }
5785    
5786            /**
5787            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5788            *
5789            * @param groupId the group ID
5790            * @param userId the user ID
5791            * @param classNameId the class name ID
5792            * @return the number of matching journal articles
5793            * @throws SystemException if a system exception occurred
5794            */
5795            public static int countByG_U_C(long groupId, long userId, long classNameId)
5796                    throws com.liferay.portal.kernel.exception.SystemException {
5797                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
5798            }
5799    
5800            /**
5801            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5802            *
5803            * @param groupId the group ID
5804            * @param userId the user ID
5805            * @param classNameId the class name ID
5806            * @return the number of matching journal articles that the user has permission to view
5807            * @throws SystemException if a system exception occurred
5808            */
5809            public static int filterCountByG_U_C(long groupId, long userId,
5810                    long classNameId)
5811                    throws com.liferay.portal.kernel.exception.SystemException {
5812                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
5813            }
5814    
5815            /**
5816            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5817            *
5818            * @param groupId the group ID
5819            * @param folderId the folder ID
5820            * @param status the status
5821            * @return the matching journal articles
5822            * @throws SystemException if a system exception occurred
5823            */
5824            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5825                    long groupId, long folderId, int status)
5826                    throws com.liferay.portal.kernel.exception.SystemException {
5827                    return getPersistence().findByG_F_ST(groupId, folderId, status);
5828            }
5829    
5830            /**
5831            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5832            *
5833            * <p>
5834            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5835            * </p>
5836            *
5837            * @param groupId the group ID
5838            * @param folderId the folder ID
5839            * @param status the status
5840            * @param start the lower bound of the range of journal articles
5841            * @param end the upper bound of the range of journal articles (not inclusive)
5842            * @return the range of matching journal articles
5843            * @throws SystemException if a system exception occurred
5844            */
5845            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5846                    long groupId, long folderId, int status, int start, int end)
5847                    throws com.liferay.portal.kernel.exception.SystemException {
5848                    return getPersistence()
5849                                       .findByG_F_ST(groupId, folderId, status, start, end);
5850            }
5851    
5852            /**
5853            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5854            *
5855            * <p>
5856            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5857            * </p>
5858            *
5859            * @param groupId the group ID
5860            * @param folderId the folder ID
5861            * @param status the status
5862            * @param start the lower bound of the range of journal articles
5863            * @param end the upper bound of the range of journal articles (not inclusive)
5864            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5865            * @return the ordered range of matching journal articles
5866            * @throws SystemException if a system exception occurred
5867            */
5868            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5869                    long groupId, long folderId, int status, int start, int end,
5870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5871                    throws com.liferay.portal.kernel.exception.SystemException {
5872                    return getPersistence()
5873                                       .findByG_F_ST(groupId, folderId, status, start, end,
5874                            orderByComparator);
5875            }
5876    
5877            /**
5878            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5879            *
5880            * @param groupId the group ID
5881            * @param folderId the folder ID
5882            * @param status the status
5883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5884            * @return the first matching journal article
5885            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5886            * @throws SystemException if a system exception occurred
5887            */
5888            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
5889                    long groupId, long folderId, int status,
5890                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5891                    throws com.liferay.portal.kernel.exception.SystemException,
5892                            com.liferay.portlet.journal.NoSuchArticleException {
5893                    return getPersistence()
5894                                       .findByG_F_ST_First(groupId, folderId, status,
5895                            orderByComparator);
5896            }
5897    
5898            /**
5899            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5900            *
5901            * @param groupId the group ID
5902            * @param folderId the folder ID
5903            * @param status the status
5904            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5905            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5906            * @throws SystemException if a system exception occurred
5907            */
5908            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
5909                    long groupId, long folderId, int status,
5910                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5911                    throws com.liferay.portal.kernel.exception.SystemException {
5912                    return getPersistence()
5913                                       .fetchByG_F_ST_First(groupId, folderId, status,
5914                            orderByComparator);
5915            }
5916    
5917            /**
5918            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5919            *
5920            * @param groupId the group ID
5921            * @param folderId the folder ID
5922            * @param status the status
5923            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5924            * @return the last matching journal article
5925            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5926            * @throws SystemException if a system exception occurred
5927            */
5928            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
5929                    long groupId, long folderId, int status,
5930                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5931                    throws com.liferay.portal.kernel.exception.SystemException,
5932                            com.liferay.portlet.journal.NoSuchArticleException {
5933                    return getPersistence()
5934                                       .findByG_F_ST_Last(groupId, folderId, status,
5935                            orderByComparator);
5936            }
5937    
5938            /**
5939            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5940            *
5941            * @param groupId the group ID
5942            * @param folderId the folder ID
5943            * @param status the status
5944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5945            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5946            * @throws SystemException if a system exception occurred
5947            */
5948            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
5949                    long groupId, long folderId, int status,
5950                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5951                    throws com.liferay.portal.kernel.exception.SystemException {
5952                    return getPersistence()
5953                                       .fetchByG_F_ST_Last(groupId, folderId, status,
5954                            orderByComparator);
5955            }
5956    
5957            /**
5958            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5959            *
5960            * @param id the primary key of the current journal article
5961            * @param groupId the group ID
5962            * @param folderId the folder ID
5963            * @param status the status
5964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5965            * @return the previous, current, and next journal article
5966            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5967            * @throws SystemException if a system exception occurred
5968            */
5969            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
5970                    long id, long groupId, long folderId, int status,
5971                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5972                    throws com.liferay.portal.kernel.exception.SystemException,
5973                            com.liferay.portlet.journal.NoSuchArticleException {
5974                    return getPersistence()
5975                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
5976                            orderByComparator);
5977            }
5978    
5979            /**
5980            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5981            *
5982            * @param groupId the group ID
5983            * @param folderId the folder ID
5984            * @param status the status
5985            * @return the matching journal articles that the user has permission to view
5986            * @throws SystemException if a system exception occurred
5987            */
5988            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5989                    long groupId, long folderId, int status)
5990                    throws com.liferay.portal.kernel.exception.SystemException {
5991                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
5992            }
5993    
5994            /**
5995            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5996            *
5997            * <p>
5998            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5999            * </p>
6000            *
6001            * @param groupId the group ID
6002            * @param folderId the folder ID
6003            * @param status the status
6004            * @param start the lower bound of the range of journal articles
6005            * @param end the upper bound of the range of journal articles (not inclusive)
6006            * @return the range of matching journal articles that the user has permission to view
6007            * @throws SystemException if a system exception occurred
6008            */
6009            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6010                    long groupId, long folderId, int status, int start, int end)
6011                    throws com.liferay.portal.kernel.exception.SystemException {
6012                    return getPersistence()
6013                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
6014            }
6015    
6016            /**
6017            * 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;.
6018            *
6019            * <p>
6020            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6021            * </p>
6022            *
6023            * @param groupId the group ID
6024            * @param folderId the folder ID
6025            * @param status the status
6026            * @param start the lower bound of the range of journal articles
6027            * @param end the upper bound of the range of journal articles (not inclusive)
6028            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6029            * @return the ordered range of matching journal articles that the user has permission to view
6030            * @throws SystemException if a system exception occurred
6031            */
6032            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6033                    long groupId, long folderId, int status, int start, int end,
6034                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6035                    throws com.liferay.portal.kernel.exception.SystemException {
6036                    return getPersistence()
6037                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
6038                            orderByComparator);
6039            }
6040    
6041            /**
6042            * 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;.
6043            *
6044            * @param id the primary key of the current journal article
6045            * @param groupId the group ID
6046            * @param folderId the folder ID
6047            * @param status the status
6048            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6049            * @return the previous, current, and next journal article
6050            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6051            * @throws SystemException if a system exception occurred
6052            */
6053            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
6054                    long id, long groupId, long folderId, int status,
6055                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6056                    throws com.liferay.portal.kernel.exception.SystemException,
6057                            com.liferay.portlet.journal.NoSuchArticleException {
6058                    return getPersistence()
6059                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
6060                            status, orderByComparator);
6061            }
6062    
6063            /**
6064            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
6065            *
6066            * @param groupId the group ID
6067            * @param folderId the folder ID
6068            * @param statuses the statuses
6069            * @return the matching journal articles that the user has permission to view
6070            * @throws SystemException if a system exception occurred
6071            */
6072            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6073                    long groupId, long folderId, int[] statuses)
6074                    throws com.liferay.portal.kernel.exception.SystemException {
6075                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
6076            }
6077    
6078            /**
6079            * 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;.
6080            *
6081            * <p>
6082            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6083            * </p>
6084            *
6085            * @param groupId the group ID
6086            * @param folderId the folder ID
6087            * @param statuses the statuses
6088            * @param start the lower bound of the range of journal articles
6089            * @param end the upper bound of the range of journal articles (not inclusive)
6090            * @return the range of matching journal articles that the user has permission to view
6091            * @throws SystemException if a system exception occurred
6092            */
6093            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6094                    long groupId, long folderId, int[] statuses, int start, int end)
6095                    throws com.liferay.portal.kernel.exception.SystemException {
6096                    return getPersistence()
6097                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
6098            }
6099    
6100            /**
6101            * 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;.
6102            *
6103            * <p>
6104            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6105            * </p>
6106            *
6107            * @param groupId the group ID
6108            * @param folderId the folder ID
6109            * @param statuses the statuses
6110            * @param start the lower bound of the range of journal articles
6111            * @param end the upper bound of the range of journal articles (not inclusive)
6112            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6113            * @return the ordered range of matching journal articles that the user has permission to view
6114            * @throws SystemException if a system exception occurred
6115            */
6116            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6117                    long groupId, long folderId, int[] statuses, int start, int end,
6118                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6119                    throws com.liferay.portal.kernel.exception.SystemException {
6120                    return getPersistence()
6121                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
6122                            orderByComparator);
6123            }
6124    
6125            /**
6126            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6127            *
6128            * <p>
6129            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6130            * </p>
6131            *
6132            * @param groupId the group ID
6133            * @param folderId the folder ID
6134            * @param statuses the statuses
6135            * @return the matching journal articles
6136            * @throws SystemException if a system exception occurred
6137            */
6138            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6139                    long groupId, long folderId, int[] statuses)
6140                    throws com.liferay.portal.kernel.exception.SystemException {
6141                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
6142            }
6143    
6144            /**
6145            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6146            *
6147            * <p>
6148            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6149            * </p>
6150            *
6151            * @param groupId the group ID
6152            * @param folderId the folder ID
6153            * @param statuses the statuses
6154            * @param start the lower bound of the range of journal articles
6155            * @param end the upper bound of the range of journal articles (not inclusive)
6156            * @return the range of matching journal articles
6157            * @throws SystemException if a system exception occurred
6158            */
6159            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6160                    long groupId, long folderId, int[] statuses, int start, int end)
6161                    throws com.liferay.portal.kernel.exception.SystemException {
6162                    return getPersistence()
6163                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
6164            }
6165    
6166            /**
6167            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6168            *
6169            * <p>
6170            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6171            * </p>
6172            *
6173            * @param groupId the group ID
6174            * @param folderId the folder ID
6175            * @param statuses the statuses
6176            * @param start the lower bound of the range of journal articles
6177            * @param end the upper bound of the range of journal articles (not inclusive)
6178            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6179            * @return the ordered range of matching journal articles
6180            * @throws SystemException if a system exception occurred
6181            */
6182            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6183                    long groupId, long folderId, int[] statuses, int start, int end,
6184                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6185                    throws com.liferay.portal.kernel.exception.SystemException {
6186                    return getPersistence()
6187                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
6188                            orderByComparator);
6189            }
6190    
6191            /**
6192            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
6193            *
6194            * @param groupId the group ID
6195            * @param folderId the folder ID
6196            * @param status the status
6197            * @throws SystemException if a system exception occurred
6198            */
6199            public static void removeByG_F_ST(long groupId, long folderId, int status)
6200                    throws com.liferay.portal.kernel.exception.SystemException {
6201                    getPersistence().removeByG_F_ST(groupId, folderId, status);
6202            }
6203    
6204            /**
6205            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6206            *
6207            * @param groupId the group ID
6208            * @param folderId the folder ID
6209            * @param status the status
6210            * @return the number of matching journal articles
6211            * @throws SystemException if a system exception occurred
6212            */
6213            public static int countByG_F_ST(long groupId, long folderId, int status)
6214                    throws com.liferay.portal.kernel.exception.SystemException {
6215                    return getPersistence().countByG_F_ST(groupId, folderId, status);
6216            }
6217    
6218            /**
6219            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6220            *
6221            * @param groupId the group ID
6222            * @param folderId the folder ID
6223            * @param statuses the statuses
6224            * @return the number of matching journal articles
6225            * @throws SystemException if a system exception occurred
6226            */
6227            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
6228                    throws com.liferay.portal.kernel.exception.SystemException {
6229                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
6230            }
6231    
6232            /**
6233            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6234            *
6235            * @param groupId the group ID
6236            * @param folderId the folder ID
6237            * @param status the status
6238            * @return the number of matching journal articles that the user has permission to view
6239            * @throws SystemException if a system exception occurred
6240            */
6241            public static int filterCountByG_F_ST(long groupId, long folderId,
6242                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6243                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
6244            }
6245    
6246            /**
6247            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
6248            *
6249            * @param groupId the group ID
6250            * @param folderId the folder ID
6251            * @param statuses the statuses
6252            * @return the number of matching journal articles that the user has permission to view
6253            * @throws SystemException if a system exception occurred
6254            */
6255            public static int filterCountByG_F_ST(long groupId, long folderId,
6256                    int[] statuses)
6257                    throws com.liferay.portal.kernel.exception.SystemException {
6258                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
6259            }
6260    
6261            /**
6262            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6263            *
6264            * @param groupId the group ID
6265            * @param classNameId the class name ID
6266            * @param classPK the class p k
6267            * @return the matching journal articles
6268            * @throws SystemException if a system exception occurred
6269            */
6270            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6271                    long groupId, long classNameId, long classPK)
6272                    throws com.liferay.portal.kernel.exception.SystemException {
6273                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
6274            }
6275    
6276            /**
6277            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#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 classNameId the class name ID
6285            * @param classPK the class p k
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            * @return the range of matching journal articles
6289            * @throws SystemException if a system exception occurred
6290            */
6291            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6292                    long groupId, long classNameId, long classPK, int start, int end)
6293                    throws com.liferay.portal.kernel.exception.SystemException {
6294                    return getPersistence()
6295                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
6296            }
6297    
6298            /**
6299            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6300            *
6301            * <p>
6302            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6303            * </p>
6304            *
6305            * @param groupId the group ID
6306            * @param classNameId the class name ID
6307            * @param classPK the class p k
6308            * @param start the lower bound of the range of journal articles
6309            * @param end the upper bound of the range of journal articles (not inclusive)
6310            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6311            * @return the ordered range of 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_C_C(
6315                    long groupId, long classNameId, long classPK, int start, int end,
6316                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6317                    throws com.liferay.portal.kernel.exception.SystemException {
6318                    return getPersistence()
6319                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
6320                            orderByComparator);
6321            }
6322    
6323            /**
6324            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6325            *
6326            * @param groupId the group ID
6327            * @param classNameId the class name ID
6328            * @param classPK the class p k
6329            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6330            * @return the first matching journal article
6331            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6332            * @throws SystemException if a system exception occurred
6333            */
6334            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
6335                    long groupId, long classNameId, long classPK,
6336                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6337                    throws com.liferay.portal.kernel.exception.SystemException,
6338                            com.liferay.portlet.journal.NoSuchArticleException {
6339                    return getPersistence()
6340                                       .findByG_C_C_First(groupId, classNameId, classPK,
6341                            orderByComparator);
6342            }
6343    
6344            /**
6345            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6346            *
6347            * @param groupId the group ID
6348            * @param classNameId the class name ID
6349            * @param classPK the class p k
6350            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6351            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6352            * @throws SystemException if a system exception occurred
6353            */
6354            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
6355                    long groupId, long classNameId, long classPK,
6356                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6357                    throws com.liferay.portal.kernel.exception.SystemException {
6358                    return getPersistence()
6359                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
6360                            orderByComparator);
6361            }
6362    
6363            /**
6364            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6365            *
6366            * @param groupId the group ID
6367            * @param classNameId the class name ID
6368            * @param classPK the class p k
6369            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6370            * @return the last matching journal article
6371            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6372            * @throws SystemException if a system exception occurred
6373            */
6374            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
6375                    long groupId, long classNameId, long classPK,
6376                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6377                    throws com.liferay.portal.kernel.exception.SystemException,
6378                            com.liferay.portlet.journal.NoSuchArticleException {
6379                    return getPersistence()
6380                                       .findByG_C_C_Last(groupId, classNameId, classPK,
6381                            orderByComparator);
6382            }
6383    
6384            /**
6385            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6386            *
6387            * @param groupId the group ID
6388            * @param classNameId the class name ID
6389            * @param classPK the class p k
6390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6391            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6392            * @throws SystemException if a system exception occurred
6393            */
6394            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
6395                    long groupId, long classNameId, long classPK,
6396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6397                    throws com.liferay.portal.kernel.exception.SystemException {
6398                    return getPersistence()
6399                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
6400                            orderByComparator);
6401            }
6402    
6403            /**
6404            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6405            *
6406            * @param id the primary key of the current journal article
6407            * @param groupId the group ID
6408            * @param classNameId the class name ID
6409            * @param classPK the class p k
6410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6411            * @return the previous, current, and next journal article
6412            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6413            * @throws SystemException if a system exception occurred
6414            */
6415            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
6416                    long id, long groupId, long classNameId, long classPK,
6417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6418                    throws com.liferay.portal.kernel.exception.SystemException,
6419                            com.liferay.portlet.journal.NoSuchArticleException {
6420                    return getPersistence()
6421                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
6422                            orderByComparator);
6423            }
6424    
6425            /**
6426            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6427            *
6428            * @param groupId the group ID
6429            * @param classNameId the class name ID
6430            * @param classPK the class p k
6431            * @return the matching journal articles that the user has permission to view
6432            * @throws SystemException if a system exception occurred
6433            */
6434            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6435                    long groupId, long classNameId, long classPK)
6436                    throws com.liferay.portal.kernel.exception.SystemException {
6437                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
6438            }
6439    
6440            /**
6441            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6442            *
6443            * <p>
6444            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6445            * </p>
6446            *
6447            * @param groupId the group ID
6448            * @param classNameId the class name ID
6449            * @param classPK the class p k
6450            * @param start the lower bound of the range of journal articles
6451            * @param end the upper bound of the range of journal articles (not inclusive)
6452            * @return the range of matching journal articles that the user has permission to view
6453            * @throws SystemException if a system exception occurred
6454            */
6455            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6456                    long groupId, long classNameId, long classPK, int start, int end)
6457                    throws com.liferay.portal.kernel.exception.SystemException {
6458                    return getPersistence()
6459                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
6460            }
6461    
6462            /**
6463            * 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;.
6464            *
6465            * <p>
6466            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6467            * </p>
6468            *
6469            * @param groupId the group ID
6470            * @param classNameId the class name ID
6471            * @param classPK the class p k
6472            * @param start the lower bound of the range of journal articles
6473            * @param end the upper bound of the range of journal articles (not inclusive)
6474            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6475            * @return the ordered range of matching journal articles that the user has permission to view
6476            * @throws SystemException if a system exception occurred
6477            */
6478            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
6479                    long groupId, long classNameId, long classPK, int start, int end,
6480                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6481                    throws com.liferay.portal.kernel.exception.SystemException {
6482                    return getPersistence()
6483                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
6484                            end, orderByComparator);
6485            }
6486    
6487            /**
6488            * 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;.
6489            *
6490            * @param id the primary key of the current journal article
6491            * @param groupId the group ID
6492            * @param classNameId the class name ID
6493            * @param classPK the class p k
6494            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6495            * @return the previous, current, and next journal article
6496            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6497            * @throws SystemException if a system exception occurred
6498            */
6499            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
6500                    long id, long groupId, long classNameId, long classPK,
6501                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6502                    throws com.liferay.portal.kernel.exception.SystemException,
6503                            com.liferay.portlet.journal.NoSuchArticleException {
6504                    return getPersistence()
6505                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
6506                            classPK, orderByComparator);
6507            }
6508    
6509            /**
6510            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
6511            *
6512            * @param groupId the group ID
6513            * @param classNameId the class name ID
6514            * @param classPK the class p k
6515            * @throws SystemException if a system exception occurred
6516            */
6517            public static void removeByG_C_C(long groupId, long classNameId,
6518                    long classPK)
6519                    throws com.liferay.portal.kernel.exception.SystemException {
6520                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
6521            }
6522    
6523            /**
6524            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6525            *
6526            * @param groupId the group ID
6527            * @param classNameId the class name ID
6528            * @param classPK the class p k
6529            * @return the number of matching journal articles
6530            * @throws SystemException if a system exception occurred
6531            */
6532            public static int countByG_C_C(long groupId, long classNameId, long classPK)
6533                    throws com.liferay.portal.kernel.exception.SystemException {
6534                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
6535            }
6536    
6537            /**
6538            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6539            *
6540            * @param groupId the group ID
6541            * @param classNameId the class name ID
6542            * @param classPK the class p k
6543            * @return the number of matching journal articles that the user has permission to view
6544            * @throws SystemException if a system exception occurred
6545            */
6546            public static int filterCountByG_C_C(long groupId, long classNameId,
6547                    long classPK)
6548                    throws com.liferay.portal.kernel.exception.SystemException {
6549                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
6550            }
6551    
6552            /**
6553            * 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.
6554            *
6555            * @param groupId the group ID
6556            * @param classNameId the class name ID
6557            * @param structureId the structure ID
6558            * @return the matching journal article
6559            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6560            * @throws SystemException if a system exception occurred
6561            */
6562            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
6563                    long groupId, long classNameId, java.lang.String structureId)
6564                    throws com.liferay.portal.kernel.exception.SystemException,
6565                            com.liferay.portlet.journal.NoSuchArticleException {
6566                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
6567            }
6568    
6569            /**
6570            * 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.
6571            *
6572            * @param groupId the group ID
6573            * @param classNameId the class name ID
6574            * @param structureId the structure ID
6575            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6576            * @throws SystemException if a system exception occurred
6577            */
6578            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6579                    long groupId, long classNameId, java.lang.String structureId)
6580                    throws com.liferay.portal.kernel.exception.SystemException {
6581                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
6582            }
6583    
6584            /**
6585            * 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.
6586            *
6587            * @param groupId the group ID
6588            * @param classNameId the class name ID
6589            * @param structureId the structure ID
6590            * @param retrieveFromCache whether to use the finder cache
6591            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6592            * @throws SystemException if a system exception occurred
6593            */
6594            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6595                    long groupId, long classNameId, java.lang.String structureId,
6596                    boolean retrieveFromCache)
6597                    throws com.liferay.portal.kernel.exception.SystemException {
6598                    return getPersistence()
6599                                       .fetchByG_C_S(groupId, classNameId, structureId,
6600                            retrieveFromCache);
6601            }
6602    
6603            /**
6604            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
6605            *
6606            * @param groupId the group ID
6607            * @param classNameId the class name ID
6608            * @param structureId the structure ID
6609            * @return the journal article that was removed
6610            * @throws SystemException if a system exception occurred
6611            */
6612            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
6613                    long groupId, long classNameId, java.lang.String structureId)
6614                    throws com.liferay.portal.kernel.exception.SystemException,
6615                            com.liferay.portlet.journal.NoSuchArticleException {
6616                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
6617            }
6618    
6619            /**
6620            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
6621            *
6622            * @param groupId the group ID
6623            * @param classNameId the class name ID
6624            * @param structureId the structure ID
6625            * @return the number of matching journal articles
6626            * @throws SystemException if a system exception occurred
6627            */
6628            public static int countByG_C_S(long groupId, long classNameId,
6629                    java.lang.String structureId)
6630                    throws com.liferay.portal.kernel.exception.SystemException {
6631                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
6632            }
6633    
6634            /**
6635            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6636            *
6637            * @param groupId the group ID
6638            * @param classNameId the class name ID
6639            * @param templateId the template ID
6640            * @return the matching journal articles
6641            * @throws SystemException if a system exception occurred
6642            */
6643            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6644                    long groupId, long classNameId, java.lang.String templateId)
6645                    throws com.liferay.portal.kernel.exception.SystemException {
6646                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
6647            }
6648    
6649            /**
6650            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6651            *
6652            * <p>
6653            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6654            * </p>
6655            *
6656            * @param groupId the group ID
6657            * @param classNameId the class name ID
6658            * @param templateId the template ID
6659            * @param start the lower bound of the range of journal articles
6660            * @param end the upper bound of the range of journal articles (not inclusive)
6661            * @return the range of matching journal articles
6662            * @throws SystemException if a system exception occurred
6663            */
6664            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6665                    long groupId, long classNameId, java.lang.String templateId, int start,
6666                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6667                    return getPersistence()
6668                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
6669            }
6670    
6671            /**
6672            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6673            *
6674            * <p>
6675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6676            * </p>
6677            *
6678            * @param groupId the group ID
6679            * @param classNameId the class name ID
6680            * @param templateId the template ID
6681            * @param start the lower bound of the range of journal articles
6682            * @param end the upper bound of the range of journal articles (not inclusive)
6683            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6684            * @return the ordered range of matching journal articles
6685            * @throws SystemException if a system exception occurred
6686            */
6687            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6688                    long groupId, long classNameId, java.lang.String templateId, int start,
6689                    int end,
6690                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6691                    throws com.liferay.portal.kernel.exception.SystemException {
6692                    return getPersistence()
6693                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
6694                            orderByComparator);
6695            }
6696    
6697            /**
6698            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6699            *
6700            * @param groupId the group ID
6701            * @param classNameId the class name ID
6702            * @param templateId the template ID
6703            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6704            * @return the first matching journal article
6705            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6706            * @throws SystemException if a system exception occurred
6707            */
6708            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
6709                    long groupId, long classNameId, java.lang.String templateId,
6710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6711                    throws com.liferay.portal.kernel.exception.SystemException,
6712                            com.liferay.portlet.journal.NoSuchArticleException {
6713                    return getPersistence()
6714                                       .findByG_C_T_First(groupId, classNameId, templateId,
6715                            orderByComparator);
6716            }
6717    
6718            /**
6719            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6720            *
6721            * @param groupId the group ID
6722            * @param classNameId the class name ID
6723            * @param templateId the template ID
6724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6725            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6726            * @throws SystemException if a system exception occurred
6727            */
6728            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
6729                    long groupId, long classNameId, java.lang.String templateId,
6730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6731                    throws com.liferay.portal.kernel.exception.SystemException {
6732                    return getPersistence()
6733                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
6734                            orderByComparator);
6735            }
6736    
6737            /**
6738            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6739            *
6740            * @param groupId the group ID
6741            * @param classNameId the class name ID
6742            * @param templateId the template ID
6743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6744            * @return the last matching journal article
6745            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6746            * @throws SystemException if a system exception occurred
6747            */
6748            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
6749                    long groupId, long classNameId, java.lang.String templateId,
6750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6751                    throws com.liferay.portal.kernel.exception.SystemException,
6752                            com.liferay.portlet.journal.NoSuchArticleException {
6753                    return getPersistence()
6754                                       .findByG_C_T_Last(groupId, classNameId, templateId,
6755                            orderByComparator);
6756            }
6757    
6758            /**
6759            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6760            *
6761            * @param groupId the group ID
6762            * @param classNameId the class name ID
6763            * @param templateId the template ID
6764            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6765            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6766            * @throws SystemException if a system exception occurred
6767            */
6768            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
6769                    long groupId, long classNameId, java.lang.String templateId,
6770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6771                    throws com.liferay.portal.kernel.exception.SystemException {
6772                    return getPersistence()
6773                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
6774                            orderByComparator);
6775            }
6776    
6777            /**
6778            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6779            *
6780            * @param id the primary key of the current journal article
6781            * @param groupId the group ID
6782            * @param classNameId the class name ID
6783            * @param templateId the template ID
6784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6785            * @return the previous, current, and next journal article
6786            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6787            * @throws SystemException if a system exception occurred
6788            */
6789            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
6790                    long id, long groupId, long classNameId, java.lang.String templateId,
6791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6792                    throws com.liferay.portal.kernel.exception.SystemException,
6793                            com.liferay.portlet.journal.NoSuchArticleException {
6794                    return getPersistence()
6795                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
6796                            templateId, orderByComparator);
6797            }
6798    
6799            /**
6800            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6801            *
6802            * @param groupId the group ID
6803            * @param classNameId the class name ID
6804            * @param templateId the template ID
6805            * @return the matching journal articles that the user has permission to view
6806            * @throws SystemException if a system exception occurred
6807            */
6808            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6809                    long groupId, long classNameId, java.lang.String templateId)
6810                    throws com.liferay.portal.kernel.exception.SystemException {
6811                    return getPersistence()
6812                                       .filterFindByG_C_T(groupId, classNameId, templateId);
6813            }
6814    
6815            /**
6816            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6817            *
6818            * <p>
6819            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6820            * </p>
6821            *
6822            * @param groupId the group ID
6823            * @param classNameId the class name ID
6824            * @param templateId the template ID
6825            * @param start the lower bound of the range of journal articles
6826            * @param end the upper bound of the range of journal articles (not inclusive)
6827            * @return the range of matching journal articles that the user has permission to view
6828            * @throws SystemException if a system exception occurred
6829            */
6830            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6831                    long groupId, long classNameId, java.lang.String templateId, int start,
6832                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6833                    return getPersistence()
6834                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6835                            end);
6836            }
6837    
6838            /**
6839            * 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;.
6840            *
6841            * <p>
6842            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6843            * </p>
6844            *
6845            * @param groupId the group ID
6846            * @param classNameId the class name ID
6847            * @param templateId the template ID
6848            * @param start the lower bound of the range of journal articles
6849            * @param end the upper bound of the range of journal articles (not inclusive)
6850            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6851            * @return the ordered range of matching journal articles that the user has permission to view
6852            * @throws SystemException if a system exception occurred
6853            */
6854            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6855                    long groupId, long classNameId, java.lang.String templateId, int start,
6856                    int end,
6857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6858                    throws com.liferay.portal.kernel.exception.SystemException {
6859                    return getPersistence()
6860                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6861                            end, orderByComparator);
6862            }
6863    
6864            /**
6865            * 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;.
6866            *
6867            * @param id the primary key of the current journal article
6868            * @param groupId the group ID
6869            * @param classNameId the class name ID
6870            * @param templateId the template ID
6871            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6872            * @return the previous, current, and next journal article
6873            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6874            * @throws SystemException if a system exception occurred
6875            */
6876            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
6877                    long id, long groupId, long classNameId, java.lang.String templateId,
6878                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6879                    throws com.liferay.portal.kernel.exception.SystemException,
6880                            com.liferay.portlet.journal.NoSuchArticleException {
6881                    return getPersistence()
6882                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
6883                            templateId, orderByComparator);
6884            }
6885    
6886            /**
6887            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
6888            *
6889            * @param groupId the group ID
6890            * @param classNameId the class name ID
6891            * @param templateId the template ID
6892            * @throws SystemException if a system exception occurred
6893            */
6894            public static void removeByG_C_T(long groupId, long classNameId,
6895                    java.lang.String templateId)
6896                    throws com.liferay.portal.kernel.exception.SystemException {
6897                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
6898            }
6899    
6900            /**
6901            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6902            *
6903            * @param groupId the group ID
6904            * @param classNameId the class name ID
6905            * @param templateId the template ID
6906            * @return the number of matching journal articles
6907            * @throws SystemException if a system exception occurred
6908            */
6909            public static int countByG_C_T(long groupId, long classNameId,
6910                    java.lang.String templateId)
6911                    throws com.liferay.portal.kernel.exception.SystemException {
6912                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
6913            }
6914    
6915            /**
6916            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6917            *
6918            * @param groupId the group ID
6919            * @param classNameId the class name ID
6920            * @param templateId the template ID
6921            * @return the number of matching journal articles that the user has permission to view
6922            * @throws SystemException if a system exception occurred
6923            */
6924            public static int filterCountByG_C_T(long groupId, long classNameId,
6925                    java.lang.String templateId)
6926                    throws com.liferay.portal.kernel.exception.SystemException {
6927                    return getPersistence()
6928                                       .filterCountByG_C_T(groupId, classNameId, templateId);
6929            }
6930    
6931            /**
6932            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6933            *
6934            * @param groupId the group ID
6935            * @param classNameId the class name ID
6936            * @param layoutUuid the layout uuid
6937            * @return the matching journal articles
6938            * @throws SystemException if a system exception occurred
6939            */
6940            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6941                    long groupId, long classNameId, java.lang.String layoutUuid)
6942                    throws com.liferay.portal.kernel.exception.SystemException {
6943                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
6944            }
6945    
6946            /**
6947            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6948            *
6949            * <p>
6950            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6951            * </p>
6952            *
6953            * @param groupId the group ID
6954            * @param classNameId the class name ID
6955            * @param layoutUuid the layout uuid
6956            * @param start the lower bound of the range of journal articles
6957            * @param end the upper bound of the range of journal articles (not inclusive)
6958            * @return the range of matching journal articles
6959            * @throws SystemException if a system exception occurred
6960            */
6961            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6962                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6963                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6964                    return getPersistence()
6965                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6966            }
6967    
6968            /**
6969            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6970            *
6971            * <p>
6972            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6973            * </p>
6974            *
6975            * @param groupId the group ID
6976            * @param classNameId the class name ID
6977            * @param layoutUuid the layout uuid
6978            * @param start the lower bound of the range of journal articles
6979            * @param end the upper bound of the range of journal articles (not inclusive)
6980            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6981            * @return the ordered range of matching journal articles
6982            * @throws SystemException if a system exception occurred
6983            */
6984            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6985                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6986                    int end,
6987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6988                    throws com.liferay.portal.kernel.exception.SystemException {
6989                    return getPersistence()
6990                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6991                            orderByComparator);
6992            }
6993    
6994            /**
6995            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6996            *
6997            * @param groupId the group ID
6998            * @param classNameId the class name ID
6999            * @param layoutUuid the layout uuid
7000            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7001            * @return the first matching journal article
7002            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7003            * @throws SystemException if a system exception occurred
7004            */
7005            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
7006                    long groupId, long classNameId, java.lang.String layoutUuid,
7007                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7008                    throws com.liferay.portal.kernel.exception.SystemException,
7009                            com.liferay.portlet.journal.NoSuchArticleException {
7010                    return getPersistence()
7011                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
7012                            orderByComparator);
7013            }
7014    
7015            /**
7016            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7017            *
7018            * @param groupId the group ID
7019            * @param classNameId the class name ID
7020            * @param layoutUuid the layout uuid
7021            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7022            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7023            * @throws SystemException if a system exception occurred
7024            */
7025            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
7026                    long groupId, long classNameId, java.lang.String layoutUuid,
7027                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7028                    throws com.liferay.portal.kernel.exception.SystemException {
7029                    return getPersistence()
7030                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
7031                            orderByComparator);
7032            }
7033    
7034            /**
7035            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7036            *
7037            * @param groupId the group ID
7038            * @param classNameId the class name ID
7039            * @param layoutUuid the layout uuid
7040            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7041            * @return the last matching journal article
7042            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7043            * @throws SystemException if a system exception occurred
7044            */
7045            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
7046                    long groupId, long classNameId, java.lang.String layoutUuid,
7047                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7048                    throws com.liferay.portal.kernel.exception.SystemException,
7049                            com.liferay.portlet.journal.NoSuchArticleException {
7050                    return getPersistence()
7051                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
7052                            orderByComparator);
7053            }
7054    
7055            /**
7056            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7057            *
7058            * @param groupId the group ID
7059            * @param classNameId the class name ID
7060            * @param layoutUuid the layout uuid
7061            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7062            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7063            * @throws SystemException if a system exception occurred
7064            */
7065            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
7066                    long groupId, long classNameId, java.lang.String layoutUuid,
7067                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7068                    throws com.liferay.portal.kernel.exception.SystemException {
7069                    return getPersistence()
7070                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
7071                            orderByComparator);
7072            }
7073    
7074            /**
7075            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7076            *
7077            * @param id the primary key of the current journal article
7078            * @param groupId the group ID
7079            * @param classNameId the class name ID
7080            * @param layoutUuid the layout uuid
7081            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7082            * @return the previous, current, and next journal article
7083            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7084            * @throws SystemException if a system exception occurred
7085            */
7086            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
7087                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
7088                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7089                    throws com.liferay.portal.kernel.exception.SystemException,
7090                            com.liferay.portlet.journal.NoSuchArticleException {
7091                    return getPersistence()
7092                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
7093                            layoutUuid, orderByComparator);
7094            }
7095    
7096            /**
7097            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7098            *
7099            * @param groupId the group ID
7100            * @param classNameId the class name ID
7101            * @param layoutUuid the layout uuid
7102            * @return the matching journal articles that the user has permission to view
7103            * @throws SystemException if a system exception occurred
7104            */
7105            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7106                    long groupId, long classNameId, java.lang.String layoutUuid)
7107                    throws com.liferay.portal.kernel.exception.SystemException {
7108                    return getPersistence()
7109                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
7110            }
7111    
7112            /**
7113            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7114            *
7115            * <p>
7116            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7117            * </p>
7118            *
7119            * @param groupId the group ID
7120            * @param classNameId the class name ID
7121            * @param layoutUuid the layout uuid
7122            * @param start the lower bound of the range of journal articles
7123            * @param end the upper bound of the range of journal articles (not inclusive)
7124            * @return the range of matching journal articles that the user has permission to view
7125            * @throws SystemException if a system exception occurred
7126            */
7127            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7128                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7129                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7130                    return getPersistence()
7131                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
7132                            end);
7133            }
7134    
7135            /**
7136            * 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;.
7137            *
7138            * <p>
7139            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7140            * </p>
7141            *
7142            * @param groupId the group ID
7143            * @param classNameId the class name ID
7144            * @param layoutUuid the layout uuid
7145            * @param start the lower bound of the range of journal articles
7146            * @param end the upper bound of the range of journal articles (not inclusive)
7147            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7148            * @return the ordered range of matching journal articles that the user has permission to view
7149            * @throws SystemException if a system exception occurred
7150            */
7151            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7152                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7153                    int end,
7154                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7155                    throws com.liferay.portal.kernel.exception.SystemException {
7156                    return getPersistence()
7157                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
7158                            end, orderByComparator);
7159            }
7160    
7161            /**
7162            * 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;.
7163            *
7164            * @param id the primary key of the current journal article
7165            * @param groupId the group ID
7166            * @param classNameId the class name ID
7167            * @param layoutUuid the layout uuid
7168            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7169            * @return the previous, current, and next journal article
7170            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7171            * @throws SystemException if a system exception occurred
7172            */
7173            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
7174                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
7175                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7176                    throws com.liferay.portal.kernel.exception.SystemException,
7177                            com.liferay.portlet.journal.NoSuchArticleException {
7178                    return getPersistence()
7179                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
7180                            layoutUuid, orderByComparator);
7181            }
7182    
7183            /**
7184            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
7185            *
7186            * @param groupId the group ID
7187            * @param classNameId the class name ID
7188            * @param layoutUuid the layout uuid
7189            * @throws SystemException if a system exception occurred
7190            */
7191            public static void removeByG_C_L(long groupId, long classNameId,
7192                    java.lang.String layoutUuid)
7193                    throws com.liferay.portal.kernel.exception.SystemException {
7194                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
7195            }
7196    
7197            /**
7198            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7199            *
7200            * @param groupId the group ID
7201            * @param classNameId the class name ID
7202            * @param layoutUuid the layout uuid
7203            * @return the number of matching journal articles
7204            * @throws SystemException if a system exception occurred
7205            */
7206            public static int countByG_C_L(long groupId, long classNameId,
7207                    java.lang.String layoutUuid)
7208                    throws com.liferay.portal.kernel.exception.SystemException {
7209                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
7210            }
7211    
7212            /**
7213            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7214            *
7215            * @param groupId the group ID
7216            * @param classNameId the class name ID
7217            * @param layoutUuid the layout uuid
7218            * @return the number of matching journal articles that the user has permission to view
7219            * @throws SystemException if a system exception occurred
7220            */
7221            public static int filterCountByG_C_L(long groupId, long classNameId,
7222                    java.lang.String layoutUuid)
7223                    throws com.liferay.portal.kernel.exception.SystemException {
7224                    return getPersistence()
7225                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
7226            }
7227    
7228            /**
7229            * 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.
7230            *
7231            * @param groupId the group ID
7232            * @param articleId the article ID
7233            * @param version the version
7234            * @return the matching journal article
7235            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7236            * @throws SystemException if a system exception occurred
7237            */
7238            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
7239                    long groupId, java.lang.String articleId, double version)
7240                    throws com.liferay.portal.kernel.exception.SystemException,
7241                            com.liferay.portlet.journal.NoSuchArticleException {
7242                    return getPersistence().findByG_A_V(groupId, articleId, version);
7243            }
7244    
7245            /**
7246            * 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.
7247            *
7248            * @param groupId the group ID
7249            * @param articleId the article ID
7250            * @param version the version
7251            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7252            * @throws SystemException if a system exception occurred
7253            */
7254            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7255                    long groupId, java.lang.String articleId, double version)
7256                    throws com.liferay.portal.kernel.exception.SystemException {
7257                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
7258            }
7259    
7260            /**
7261            * 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.
7262            *
7263            * @param groupId the group ID
7264            * @param articleId the article ID
7265            * @param version the version
7266            * @param retrieveFromCache whether to use the finder cache
7267            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7268            * @throws SystemException if a system exception occurred
7269            */
7270            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7271                    long groupId, java.lang.String articleId, double version,
7272                    boolean retrieveFromCache)
7273                    throws com.liferay.portal.kernel.exception.SystemException {
7274                    return getPersistence()
7275                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
7276            }
7277    
7278            /**
7279            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
7280            *
7281            * @param groupId the group ID
7282            * @param articleId the article ID
7283            * @param version the version
7284            * @return the journal article that was removed
7285            * @throws SystemException if a system exception occurred
7286            */
7287            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
7288                    long groupId, java.lang.String articleId, double version)
7289                    throws com.liferay.portal.kernel.exception.SystemException,
7290                            com.liferay.portlet.journal.NoSuchArticleException {
7291                    return getPersistence().removeByG_A_V(groupId, articleId, version);
7292            }
7293    
7294            /**
7295            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
7296            *
7297            * @param groupId the group ID
7298            * @param articleId the article ID
7299            * @param version the version
7300            * @return the number of matching journal articles
7301            * @throws SystemException if a system exception occurred
7302            */
7303            public static int countByG_A_V(long groupId, java.lang.String articleId,
7304                    double version)
7305                    throws com.liferay.portal.kernel.exception.SystemException {
7306                    return getPersistence().countByG_A_V(groupId, articleId, version);
7307            }
7308    
7309            /**
7310            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7311            *
7312            * @param groupId the group ID
7313            * @param articleId the article ID
7314            * @param status the status
7315            * @return the matching journal articles
7316            * @throws SystemException if a system exception occurred
7317            */
7318            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7319                    long groupId, java.lang.String articleId, int status)
7320                    throws com.liferay.portal.kernel.exception.SystemException {
7321                    return getPersistence().findByG_A_ST(groupId, articleId, status);
7322            }
7323    
7324            /**
7325            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7326            *
7327            * <p>
7328            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7329            * </p>
7330            *
7331            * @param groupId the group ID
7332            * @param articleId the article ID
7333            * @param status the status
7334            * @param start the lower bound of the range of journal articles
7335            * @param end the upper bound of the range of journal articles (not inclusive)
7336            * @return the range of matching journal articles
7337            * @throws SystemException if a system exception occurred
7338            */
7339            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7340                    long groupId, java.lang.String articleId, int status, int start, int end)
7341                    throws com.liferay.portal.kernel.exception.SystemException {
7342                    return getPersistence()
7343                                       .findByG_A_ST(groupId, articleId, status, start, end);
7344            }
7345    
7346            /**
7347            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7348            *
7349            * <p>
7350            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7351            * </p>
7352            *
7353            * @param groupId the group ID
7354            * @param articleId the article ID
7355            * @param status the status
7356            * @param start the lower bound of the range of journal articles
7357            * @param end the upper bound of the range of journal articles (not inclusive)
7358            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7359            * @return the ordered range of matching journal articles
7360            * @throws SystemException if a system exception occurred
7361            */
7362            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7363                    long groupId, java.lang.String articleId, int status, int start,
7364                    int end,
7365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7366                    throws com.liferay.portal.kernel.exception.SystemException {
7367                    return getPersistence()
7368                                       .findByG_A_ST(groupId, articleId, status, start, end,
7369                            orderByComparator);
7370            }
7371    
7372            /**
7373            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7374            *
7375            * @param groupId the group ID
7376            * @param articleId the article ID
7377            * @param status the status
7378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7379            * @return the first matching journal article
7380            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7381            * @throws SystemException if a system exception occurred
7382            */
7383            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
7384                    long groupId, java.lang.String articleId, int status,
7385                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7386                    throws com.liferay.portal.kernel.exception.SystemException,
7387                            com.liferay.portlet.journal.NoSuchArticleException {
7388                    return getPersistence()
7389                                       .findByG_A_ST_First(groupId, articleId, status,
7390                            orderByComparator);
7391            }
7392    
7393            /**
7394            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7395            *
7396            * @param groupId the group ID
7397            * @param articleId the article ID
7398            * @param status the status
7399            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7400            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7401            * @throws SystemException if a system exception occurred
7402            */
7403            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
7404                    long groupId, java.lang.String articleId, int status,
7405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7406                    throws com.liferay.portal.kernel.exception.SystemException {
7407                    return getPersistence()
7408                                       .fetchByG_A_ST_First(groupId, articleId, status,
7409                            orderByComparator);
7410            }
7411    
7412            /**
7413            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7414            *
7415            * @param groupId the group ID
7416            * @param articleId the article ID
7417            * @param status the status
7418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7419            * @return the last matching journal article
7420            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7421            * @throws SystemException if a system exception occurred
7422            */
7423            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
7424                    long groupId, java.lang.String articleId, int status,
7425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7426                    throws com.liferay.portal.kernel.exception.SystemException,
7427                            com.liferay.portlet.journal.NoSuchArticleException {
7428                    return getPersistence()
7429                                       .findByG_A_ST_Last(groupId, articleId, status,
7430                            orderByComparator);
7431            }
7432    
7433            /**
7434            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7435            *
7436            * @param groupId the group ID
7437            * @param articleId the article ID
7438            * @param status the status
7439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7440            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7441            * @throws SystemException if a system exception occurred
7442            */
7443            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
7444                    long groupId, java.lang.String articleId, int status,
7445                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7446                    throws com.liferay.portal.kernel.exception.SystemException {
7447                    return getPersistence()
7448                                       .fetchByG_A_ST_Last(groupId, articleId, status,
7449                            orderByComparator);
7450            }
7451    
7452            /**
7453            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7454            *
7455            * @param id the primary key of the current journal article
7456            * @param groupId the group ID
7457            * @param articleId the article ID
7458            * @param status the status
7459            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7460            * @return the previous, current, and next journal article
7461            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7462            * @throws SystemException if a system exception occurred
7463            */
7464            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
7465                    long id, long groupId, java.lang.String articleId, int status,
7466                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7467                    throws com.liferay.portal.kernel.exception.SystemException,
7468                            com.liferay.portlet.journal.NoSuchArticleException {
7469                    return getPersistence()
7470                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
7471                            orderByComparator);
7472            }
7473    
7474            /**
7475            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7476            *
7477            * @param groupId the group ID
7478            * @param articleId the article ID
7479            * @param status the status
7480            * @return the matching journal articles that the user has permission to view
7481            * @throws SystemException if a system exception occurred
7482            */
7483            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7484                    long groupId, java.lang.String articleId, int status)
7485                    throws com.liferay.portal.kernel.exception.SystemException {
7486                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
7487            }
7488    
7489            /**
7490            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7491            *
7492            * <p>
7493            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7494            * </p>
7495            *
7496            * @param groupId the group ID
7497            * @param articleId the article ID
7498            * @param status the status
7499            * @param start the lower bound of the range of journal articles
7500            * @param end the upper bound of the range of journal articles (not inclusive)
7501            * @return the range of matching journal articles that the user has permission to view
7502            * @throws SystemException if a system exception occurred
7503            */
7504            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7505                    long groupId, java.lang.String articleId, int status, int start, int end)
7506                    throws com.liferay.portal.kernel.exception.SystemException {
7507                    return getPersistence()
7508                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
7509            }
7510    
7511            /**
7512            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7513            *
7514            * <p>
7515            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7516            * </p>
7517            *
7518            * @param groupId the group ID
7519            * @param articleId the article ID
7520            * @param status the status
7521            * @param start the lower bound of the range of journal articles
7522            * @param end the upper bound of the range of journal articles (not inclusive)
7523            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7524            * @return the ordered range of matching journal articles that the user has permission to view
7525            * @throws SystemException if a system exception occurred
7526            */
7527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7528                    long groupId, java.lang.String articleId, int status, int start,
7529                    int end,
7530                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7531                    throws com.liferay.portal.kernel.exception.SystemException {
7532                    return getPersistence()
7533                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
7534                            orderByComparator);
7535            }
7536    
7537            /**
7538            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7539            *
7540            * @param id the primary key of the current journal article
7541            * @param groupId the group ID
7542            * @param articleId the article ID
7543            * @param status the status
7544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7545            * @return the previous, current, and next journal article
7546            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7547            * @throws SystemException if a system exception occurred
7548            */
7549            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
7550                    long id, long groupId, java.lang.String articleId, int status,
7551                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7552                    throws com.liferay.portal.kernel.exception.SystemException,
7553                            com.liferay.portlet.journal.NoSuchArticleException {
7554                    return getPersistence()
7555                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
7556                            status, orderByComparator);
7557            }
7558    
7559            /**
7560            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7561            *
7562            * @param groupId the group ID
7563            * @param articleId the article ID
7564            * @param statuses the statuses
7565            * @return the matching journal articles that the user has permission to view
7566            * @throws SystemException if a system exception occurred
7567            */
7568            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7569                    long groupId, java.lang.String articleId, int[] statuses)
7570                    throws com.liferay.portal.kernel.exception.SystemException {
7571                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
7572            }
7573    
7574            /**
7575            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7576            *
7577            * <p>
7578            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7579            * </p>
7580            *
7581            * @param groupId the group ID
7582            * @param articleId the article ID
7583            * @param statuses the statuses
7584            * @param start the lower bound of the range of journal articles
7585            * @param end the upper bound of the range of journal articles (not inclusive)
7586            * @return the range of matching journal articles that the user has permission to view
7587            * @throws SystemException if a system exception occurred
7588            */
7589            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7590                    long groupId, java.lang.String articleId, int[] statuses, int start,
7591                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7592                    return getPersistence()
7593                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
7594            }
7595    
7596            /**
7597            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7598            *
7599            * <p>
7600            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7601            * </p>
7602            *
7603            * @param groupId the group ID
7604            * @param articleId the article ID
7605            * @param statuses the statuses
7606            * @param start the lower bound of the range of journal articles
7607            * @param end the upper bound of the range of journal articles (not inclusive)
7608            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7609            * @return the ordered range of matching journal articles that the user has permission to view
7610            * @throws SystemException if a system exception occurred
7611            */
7612            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
7613                    long groupId, java.lang.String articleId, int[] statuses, int start,
7614                    int end,
7615                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7616                    throws com.liferay.portal.kernel.exception.SystemException {
7617                    return getPersistence()
7618                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
7619                            end, orderByComparator);
7620            }
7621    
7622            /**
7623            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7624            *
7625            * <p>
7626            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7627            * </p>
7628            *
7629            * @param groupId the group ID
7630            * @param articleId the article ID
7631            * @param statuses the statuses
7632            * @return the matching journal articles
7633            * @throws SystemException if a system exception occurred
7634            */
7635            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7636                    long groupId, java.lang.String articleId, int[] statuses)
7637                    throws com.liferay.portal.kernel.exception.SystemException {
7638                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
7639            }
7640    
7641            /**
7642            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7643            *
7644            * <p>
7645            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7646            * </p>
7647            *
7648            * @param groupId the group ID
7649            * @param articleId the article ID
7650            * @param statuses the statuses
7651            * @param start the lower bound of the range of journal articles
7652            * @param end the upper bound of the range of journal articles (not inclusive)
7653            * @return the range of matching journal articles
7654            * @throws SystemException if a system exception occurred
7655            */
7656            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7657                    long groupId, java.lang.String articleId, int[] statuses, int start,
7658                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7659                    return getPersistence()
7660                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
7661            }
7662    
7663            /**
7664            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7665            *
7666            * <p>
7667            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7668            * </p>
7669            *
7670            * @param groupId the group ID
7671            * @param articleId the article ID
7672            * @param statuses the statuses
7673            * @param start the lower bound of the range of journal articles
7674            * @param end the upper bound of the range of journal articles (not inclusive)
7675            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7676            * @return the ordered range of matching journal articles
7677            * @throws SystemException if a system exception occurred
7678            */
7679            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7680                    long groupId, java.lang.String articleId, int[] statuses, int start,
7681                    int end,
7682                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7683                    throws com.liferay.portal.kernel.exception.SystemException {
7684                    return getPersistence()
7685                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
7686                            orderByComparator);
7687            }
7688    
7689            /**
7690            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
7691            *
7692            * @param groupId the group ID
7693            * @param articleId the article ID
7694            * @param status the status
7695            * @throws SystemException if a system exception occurred
7696            */
7697            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
7698                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7699                    getPersistence().removeByG_A_ST(groupId, articleId, status);
7700            }
7701    
7702            /**
7703            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7704            *
7705            * @param groupId the group ID
7706            * @param articleId the article ID
7707            * @param status the status
7708            * @return the number of matching journal articles
7709            * @throws SystemException if a system exception occurred
7710            */
7711            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7712                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7713                    return getPersistence().countByG_A_ST(groupId, articleId, status);
7714            }
7715    
7716            /**
7717            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7718            *
7719            * @param groupId the group ID
7720            * @param articleId the article ID
7721            * @param statuses the statuses
7722            * @return the number of matching journal articles
7723            * @throws SystemException if a system exception occurred
7724            */
7725            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7726                    int[] statuses)
7727                    throws com.liferay.portal.kernel.exception.SystemException {
7728                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
7729            }
7730    
7731            /**
7732            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7733            *
7734            * @param groupId the group ID
7735            * @param articleId the article ID
7736            * @param status the status
7737            * @return the number of matching journal articles that the user has permission to view
7738            * @throws SystemException if a system exception occurred
7739            */
7740            public static int filterCountByG_A_ST(long groupId,
7741                    java.lang.String articleId, int status)
7742                    throws com.liferay.portal.kernel.exception.SystemException {
7743                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
7744            }
7745    
7746            /**
7747            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7748            *
7749            * @param groupId the group ID
7750            * @param articleId the article ID
7751            * @param statuses the statuses
7752            * @return the number of matching journal articles that the user has permission to view
7753            * @throws SystemException if a system exception occurred
7754            */
7755            public static int filterCountByG_A_ST(long groupId,
7756                    java.lang.String articleId, int[] statuses)
7757                    throws com.liferay.portal.kernel.exception.SystemException {
7758                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
7759            }
7760    
7761            /**
7762            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7763            *
7764            * @param groupId the group ID
7765            * @param articleId the article ID
7766            * @param status the status
7767            * @return the matching journal articles
7768            * @throws SystemException if a system exception occurred
7769            */
7770            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
7771                    long groupId, java.lang.String articleId, int status)
7772                    throws com.liferay.portal.kernel.exception.SystemException {
7773                    return getPersistence().findByG_A_NotST(groupId, articleId, status);
7774            }
7775    
7776            /**
7777            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7778            *
7779            * <p>
7780            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7781            * </p>
7782            *
7783            * @param groupId the group ID
7784            * @param articleId the article ID
7785            * @param status the status
7786            * @param start the lower bound of the range of journal articles
7787            * @param end the upper bound of the range of journal articles (not inclusive)
7788            * @return the range of matching journal articles
7789            * @throws SystemException if a system exception occurred
7790            */
7791            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
7792                    long groupId, java.lang.String articleId, int status, int start, int end)
7793                    throws com.liferay.portal.kernel.exception.SystemException {
7794                    return getPersistence()
7795                                       .findByG_A_NotST(groupId, articleId, status, start, end);
7796            }
7797    
7798            /**
7799            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7800            *
7801            * <p>
7802            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7803            * </p>
7804            *
7805            * @param groupId the group ID
7806            * @param articleId the article ID
7807            * @param status the status
7808            * @param start the lower bound of the range of journal articles
7809            * @param end the upper bound of the range of journal articles (not inclusive)
7810            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7811            * @return the ordered range of matching journal articles
7812            * @throws SystemException if a system exception occurred
7813            */
7814            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
7815                    long groupId, java.lang.String articleId, int status, int start,
7816                    int end,
7817                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7818                    throws com.liferay.portal.kernel.exception.SystemException {
7819                    return getPersistence()
7820                                       .findByG_A_NotST(groupId, articleId, status, start, end,
7821                            orderByComparator);
7822            }
7823    
7824            /**
7825            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7826            *
7827            * @param groupId the group ID
7828            * @param articleId the article ID
7829            * @param status the status
7830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7831            * @return the first matching journal article
7832            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7833            * @throws SystemException if a system exception occurred
7834            */
7835            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_First(
7836                    long groupId, java.lang.String articleId, int status,
7837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7838                    throws com.liferay.portal.kernel.exception.SystemException,
7839                            com.liferay.portlet.journal.NoSuchArticleException {
7840                    return getPersistence()
7841                                       .findByG_A_NotST_First(groupId, articleId, status,
7842                            orderByComparator);
7843            }
7844    
7845            /**
7846            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7847            *
7848            * @param groupId the group ID
7849            * @param articleId the article ID
7850            * @param status the status
7851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7852            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7853            * @throws SystemException if a system exception occurred
7854            */
7855            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_First(
7856                    long groupId, java.lang.String articleId, int status,
7857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7858                    throws com.liferay.portal.kernel.exception.SystemException {
7859                    return getPersistence()
7860                                       .fetchByG_A_NotST_First(groupId, articleId, status,
7861                            orderByComparator);
7862            }
7863    
7864            /**
7865            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7866            *
7867            * @param groupId the group ID
7868            * @param articleId the article ID
7869            * @param status the status
7870            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7871            * @return the last matching journal article
7872            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7873            * @throws SystemException if a system exception occurred
7874            */
7875            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_Last(
7876                    long groupId, java.lang.String articleId, int status,
7877                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7878                    throws com.liferay.portal.kernel.exception.SystemException,
7879                            com.liferay.portlet.journal.NoSuchArticleException {
7880                    return getPersistence()
7881                                       .findByG_A_NotST_Last(groupId, articleId, status,
7882                            orderByComparator);
7883            }
7884    
7885            /**
7886            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7887            *
7888            * @param groupId the group ID
7889            * @param articleId the article ID
7890            * @param status the status
7891            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7892            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7893            * @throws SystemException if a system exception occurred
7894            */
7895            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_Last(
7896                    long groupId, java.lang.String articleId, int status,
7897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7898                    throws com.liferay.portal.kernel.exception.SystemException {
7899                    return getPersistence()
7900                                       .fetchByG_A_NotST_Last(groupId, articleId, status,
7901                            orderByComparator);
7902            }
7903    
7904            /**
7905            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7906            *
7907            * @param id the primary key of the current journal article
7908            * @param groupId the group ID
7909            * @param articleId the article ID
7910            * @param status the status
7911            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7912            * @return the previous, current, and next journal article
7913            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7914            * @throws SystemException if a system exception occurred
7915            */
7916            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_NotST_PrevAndNext(
7917                    long id, long groupId, java.lang.String articleId, int status,
7918                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7919                    throws com.liferay.portal.kernel.exception.SystemException,
7920                            com.liferay.portlet.journal.NoSuchArticleException {
7921                    return getPersistence()
7922                                       .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status,
7923                            orderByComparator);
7924            }
7925    
7926            /**
7927            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7928            *
7929            * @param groupId the group ID
7930            * @param articleId the article ID
7931            * @param status the status
7932            * @return the matching journal articles that the user has permission to view
7933            * @throws SystemException if a system exception occurred
7934            */
7935            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
7936                    long groupId, java.lang.String articleId, int status)
7937                    throws com.liferay.portal.kernel.exception.SystemException {
7938                    return getPersistence().filterFindByG_A_NotST(groupId, articleId, status);
7939            }
7940    
7941            /**
7942            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7943            *
7944            * <p>
7945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7946            * </p>
7947            *
7948            * @param groupId the group ID
7949            * @param articleId the article ID
7950            * @param status the status
7951            * @param start the lower bound of the range of journal articles
7952            * @param end the upper bound of the range of journal articles (not inclusive)
7953            * @return the range of matching journal articles that the user has permission to view
7954            * @throws SystemException if a system exception occurred
7955            */
7956            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
7957                    long groupId, java.lang.String articleId, int status, int start, int end)
7958                    throws com.liferay.portal.kernel.exception.SystemException {
7959                    return getPersistence()
7960                                       .filterFindByG_A_NotST(groupId, articleId, status, start, end);
7961            }
7962    
7963            /**
7964            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7965            *
7966            * <p>
7967            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7968            * </p>
7969            *
7970            * @param groupId the group ID
7971            * @param articleId the article ID
7972            * @param status the status
7973            * @param start the lower bound of the range of journal articles
7974            * @param end the upper bound of the range of journal articles (not inclusive)
7975            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7976            * @return the ordered range of matching journal articles that the user has permission to view
7977            * @throws SystemException if a system exception occurred
7978            */
7979            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
7980                    long groupId, java.lang.String articleId, int status, int start,
7981                    int end,
7982                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7983                    throws com.liferay.portal.kernel.exception.SystemException {
7984                    return getPersistence()
7985                                       .filterFindByG_A_NotST(groupId, articleId, status, start,
7986                            end, orderByComparator);
7987            }
7988    
7989            /**
7990            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7991            *
7992            * @param id the primary key of the current journal article
7993            * @param groupId the group ID
7994            * @param articleId the article ID
7995            * @param status the status
7996            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7997            * @return the previous, current, and next journal article
7998            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7999            * @throws SystemException if a system exception occurred
8000            */
8001            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_NotST_PrevAndNext(
8002                    long id, long groupId, java.lang.String articleId, int status,
8003                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8004                    throws com.liferay.portal.kernel.exception.SystemException,
8005                            com.liferay.portlet.journal.NoSuchArticleException {
8006                    return getPersistence()
8007                                       .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId,
8008                            status, orderByComparator);
8009            }
8010    
8011            /**
8012            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63; from the database.
8013            *
8014            * @param groupId the group ID
8015            * @param articleId the article ID
8016            * @param status the status
8017            * @throws SystemException if a system exception occurred
8018            */
8019            public static void removeByG_A_NotST(long groupId,
8020                    java.lang.String articleId, int status)
8021                    throws com.liferay.portal.kernel.exception.SystemException {
8022                    getPersistence().removeByG_A_NotST(groupId, articleId, status);
8023            }
8024    
8025            /**
8026            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8027            *
8028            * @param groupId the group ID
8029            * @param articleId the article ID
8030            * @param status the status
8031            * @return the number of matching journal articles
8032            * @throws SystemException if a system exception occurred
8033            */
8034            public static int countByG_A_NotST(long groupId,
8035                    java.lang.String articleId, int status)
8036                    throws com.liferay.portal.kernel.exception.SystemException {
8037                    return getPersistence().countByG_A_NotST(groupId, articleId, status);
8038            }
8039    
8040            /**
8041            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8042            *
8043            * @param groupId the group ID
8044            * @param articleId the article ID
8045            * @param status the status
8046            * @return the number of matching journal articles that the user has permission to view
8047            * @throws SystemException if a system exception occurred
8048            */
8049            public static int filterCountByG_A_NotST(long groupId,
8050                    java.lang.String articleId, int status)
8051                    throws com.liferay.portal.kernel.exception.SystemException {
8052                    return getPersistence()
8053                                       .filterCountByG_A_NotST(groupId, articleId, status);
8054            }
8055    
8056            /**
8057            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8058            *
8059            * @param groupId the group ID
8060            * @param urlTitle the url title
8061            * @param status the status
8062            * @return the matching journal articles
8063            * @throws SystemException if a system exception occurred
8064            */
8065            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
8066                    long groupId, java.lang.String urlTitle, int status)
8067                    throws com.liferay.portal.kernel.exception.SystemException {
8068                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
8069            }
8070    
8071            /**
8072            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8073            *
8074            * <p>
8075            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8076            * </p>
8077            *
8078            * @param groupId the group ID
8079            * @param urlTitle the url title
8080            * @param status the status
8081            * @param start the lower bound of the range of journal articles
8082            * @param end the upper bound of the range of journal articles (not inclusive)
8083            * @return the range of matching journal articles
8084            * @throws SystemException if a system exception occurred
8085            */
8086            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
8087                    long groupId, java.lang.String urlTitle, int status, int start, int end)
8088                    throws com.liferay.portal.kernel.exception.SystemException {
8089                    return getPersistence()
8090                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
8091            }
8092    
8093            /**
8094            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8095            *
8096            * <p>
8097            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8098            * </p>
8099            *
8100            * @param groupId the group ID
8101            * @param urlTitle the url title
8102            * @param status the status
8103            * @param start the lower bound of the range of journal articles
8104            * @param end the upper bound of the range of journal articles (not inclusive)
8105            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8106            * @return the ordered range of matching journal articles
8107            * @throws SystemException if a system exception occurred
8108            */
8109            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
8110                    long groupId, java.lang.String urlTitle, int status, int start,
8111                    int end,
8112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8113                    throws com.liferay.portal.kernel.exception.SystemException {
8114                    return getPersistence()
8115                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
8116                            orderByComparator);
8117            }
8118    
8119            /**
8120            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8121            *
8122            * @param groupId the group ID
8123            * @param urlTitle the url title
8124            * @param status the status
8125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8126            * @return the first matching journal article
8127            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8128            * @throws SystemException if a system exception occurred
8129            */
8130            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
8131                    long groupId, java.lang.String urlTitle, int status,
8132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8133                    throws com.liferay.portal.kernel.exception.SystemException,
8134                            com.liferay.portlet.journal.NoSuchArticleException {
8135                    return getPersistence()
8136                                       .findByG_UT_ST_First(groupId, urlTitle, status,
8137                            orderByComparator);
8138            }
8139    
8140            /**
8141            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8142            *
8143            * @param groupId the group ID
8144            * @param urlTitle the url title
8145            * @param status the status
8146            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8147            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
8148            * @throws SystemException if a system exception occurred
8149            */
8150            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
8151                    long groupId, java.lang.String urlTitle, int status,
8152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8153                    throws com.liferay.portal.kernel.exception.SystemException {
8154                    return getPersistence()
8155                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
8156                            orderByComparator);
8157            }
8158    
8159            /**
8160            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8161            *
8162            * @param groupId the group ID
8163            * @param urlTitle the url title
8164            * @param status the status
8165            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8166            * @return the last matching journal article
8167            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8168            * @throws SystemException if a system exception occurred
8169            */
8170            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
8171                    long groupId, java.lang.String urlTitle, int status,
8172                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8173                    throws com.liferay.portal.kernel.exception.SystemException,
8174                            com.liferay.portlet.journal.NoSuchArticleException {
8175                    return getPersistence()
8176                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
8177                            orderByComparator);
8178            }
8179    
8180            /**
8181            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8182            *
8183            * @param groupId the group ID
8184            * @param urlTitle the url title
8185            * @param status the status
8186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8187            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
8188            * @throws SystemException if a system exception occurred
8189            */
8190            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
8191                    long groupId, java.lang.String urlTitle, int status,
8192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8193                    throws com.liferay.portal.kernel.exception.SystemException {
8194                    return getPersistence()
8195                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
8196                            orderByComparator);
8197            }
8198    
8199            /**
8200            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8201            *
8202            * @param id the primary key of the current journal article
8203            * @param groupId the group ID
8204            * @param urlTitle the url title
8205            * @param status the status
8206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8207            * @return the previous, current, and next journal article
8208            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8209            * @throws SystemException if a system exception occurred
8210            */
8211            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
8212                    long id, long groupId, java.lang.String urlTitle, int status,
8213                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8214                    throws com.liferay.portal.kernel.exception.SystemException,
8215                            com.liferay.portlet.journal.NoSuchArticleException {
8216                    return getPersistence()
8217                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
8218                            orderByComparator);
8219            }
8220    
8221            /**
8222            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8223            *
8224            * @param groupId the group ID
8225            * @param urlTitle the url title
8226            * @param status the status
8227            * @return the matching journal articles that the user has permission to view
8228            * @throws SystemException if a system exception occurred
8229            */
8230            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
8231                    long groupId, java.lang.String urlTitle, int status)
8232                    throws com.liferay.portal.kernel.exception.SystemException {
8233                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
8234            }
8235    
8236            /**
8237            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8238            *
8239            * <p>
8240            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8241            * </p>
8242            *
8243            * @param groupId the group ID
8244            * @param urlTitle the url title
8245            * @param status the status
8246            * @param start the lower bound of the range of journal articles
8247            * @param end the upper bound of the range of journal articles (not inclusive)
8248            * @return the range of matching journal articles that the user has permission to view
8249            * @throws SystemException if a system exception occurred
8250            */
8251            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
8252                    long groupId, java.lang.String urlTitle, int status, int start, int end)
8253                    throws com.liferay.portal.kernel.exception.SystemException {
8254                    return getPersistence()
8255                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
8256            }
8257    
8258            /**
8259            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8260            *
8261            * <p>
8262            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8263            * </p>
8264            *
8265            * @param groupId the group ID
8266            * @param urlTitle the url title
8267            * @param status the status
8268            * @param start the lower bound of the range of journal articles
8269            * @param end the upper bound of the range of journal articles (not inclusive)
8270            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8271            * @return the ordered range of matching journal articles that the user has permission to view
8272            * @throws SystemException if a system exception occurred
8273            */
8274            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
8275                    long groupId, java.lang.String urlTitle, int status, int start,
8276                    int end,
8277                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8278                    throws com.liferay.portal.kernel.exception.SystemException {
8279                    return getPersistence()
8280                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
8281                            orderByComparator);
8282            }
8283    
8284            /**
8285            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8286            *
8287            * @param id the primary key of the current journal article
8288            * @param groupId the group ID
8289            * @param urlTitle the url title
8290            * @param status the status
8291            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8292            * @return the previous, current, and next journal article
8293            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8294            * @throws SystemException if a system exception occurred
8295            */
8296            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
8297                    long id, long groupId, java.lang.String urlTitle, int status,
8298                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8299                    throws com.liferay.portal.kernel.exception.SystemException,
8300                            com.liferay.portlet.journal.NoSuchArticleException {
8301                    return getPersistence()
8302                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
8303                            status, orderByComparator);
8304            }
8305    
8306            /**
8307            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
8308            *
8309            * @param groupId the group ID
8310            * @param urlTitle the url title
8311            * @param status the status
8312            * @throws SystemException if a system exception occurred
8313            */
8314            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
8315                    int status) throws com.liferay.portal.kernel.exception.SystemException {
8316                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
8317            }
8318    
8319            /**
8320            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8321            *
8322            * @param groupId the group ID
8323            * @param urlTitle the url title
8324            * @param status the status
8325            * @return the number of matching journal articles
8326            * @throws SystemException if a system exception occurred
8327            */
8328            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
8329                    int status) throws com.liferay.portal.kernel.exception.SystemException {
8330                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
8331            }
8332    
8333            /**
8334            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8335            *
8336            * @param groupId the group ID
8337            * @param urlTitle the url title
8338            * @param status the status
8339            * @return the number of matching journal articles that the user has permission to view
8340            * @throws SystemException if a system exception occurred
8341            */
8342            public static int filterCountByG_UT_ST(long groupId,
8343                    java.lang.String urlTitle, int status)
8344                    throws com.liferay.portal.kernel.exception.SystemException {
8345                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
8346            }
8347    
8348            /**
8349            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8350            *
8351            * @param companyId the company ID
8352            * @param version the version
8353            * @param status the status
8354            * @return the matching journal articles
8355            * @throws SystemException if a system exception occurred
8356            */
8357            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
8358                    long companyId, double version, int status)
8359                    throws com.liferay.portal.kernel.exception.SystemException {
8360                    return getPersistence().findByC_V_ST(companyId, version, status);
8361            }
8362    
8363            /**
8364            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8365            *
8366            * <p>
8367            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8368            * </p>
8369            *
8370            * @param companyId the company ID
8371            * @param version the version
8372            * @param status the status
8373            * @param start the lower bound of the range of journal articles
8374            * @param end the upper bound of the range of journal articles (not inclusive)
8375            * @return the range of matching journal articles
8376            * @throws SystemException if a system exception occurred
8377            */
8378            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
8379                    long companyId, double version, int status, int start, int end)
8380                    throws com.liferay.portal.kernel.exception.SystemException {
8381                    return getPersistence()
8382                                       .findByC_V_ST(companyId, version, status, start, end);
8383            }
8384    
8385            /**
8386            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8387            *
8388            * <p>
8389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8390            * </p>
8391            *
8392            * @param companyId the company ID
8393            * @param version the version
8394            * @param status the status
8395            * @param start the lower bound of the range of journal articles
8396            * @param end the upper bound of the range of journal articles (not inclusive)
8397            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8398            * @return the ordered range of matching journal articles
8399            * @throws SystemException if a system exception occurred
8400            */
8401            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
8402                    long companyId, double version, int status, int start, int end,
8403                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8404                    throws com.liferay.portal.kernel.exception.SystemException {
8405                    return getPersistence()
8406                                       .findByC_V_ST(companyId, version, status, start, end,
8407                            orderByComparator);
8408            }
8409    
8410            /**
8411            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
8412            *
8413            * @param companyId the company ID
8414            * @param version the version
8415            * @param status the status
8416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8417            * @return the first matching journal article
8418            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8419            * @throws SystemException if a system exception occurred
8420            */
8421            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
8422                    long companyId, double version, int status,
8423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8424                    throws com.liferay.portal.kernel.exception.SystemException,
8425                            com.liferay.portlet.journal.NoSuchArticleException {
8426                    return getPersistence()
8427                                       .findByC_V_ST_First(companyId, version, status,
8428                            orderByComparator);
8429            }
8430    
8431            /**
8432            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
8433            *
8434            * @param companyId the company ID
8435            * @param version the version
8436            * @param status the status
8437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8438            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
8439            * @throws SystemException if a system exception occurred
8440            */
8441            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
8442                    long companyId, double version, int status,
8443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8444                    throws com.liferay.portal.kernel.exception.SystemException {
8445                    return getPersistence()
8446                                       .fetchByC_V_ST_First(companyId, version, status,
8447                            orderByComparator);
8448            }
8449    
8450            /**
8451            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
8452            *
8453            * @param companyId the company ID
8454            * @param version the version
8455            * @param status the status
8456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8457            * @return the last matching journal article
8458            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8459            * @throws SystemException if a system exception occurred
8460            */
8461            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
8462                    long companyId, double version, int status,
8463                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8464                    throws com.liferay.portal.kernel.exception.SystemException,
8465                            com.liferay.portlet.journal.NoSuchArticleException {
8466                    return getPersistence()
8467                                       .findByC_V_ST_Last(companyId, version, status,
8468                            orderByComparator);
8469            }
8470    
8471            /**
8472            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
8473            *
8474            * @param companyId the company ID
8475            * @param version the version
8476            * @param status the status
8477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8478            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
8479            * @throws SystemException if a system exception occurred
8480            */
8481            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
8482                    long companyId, double version, int status,
8483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8484                    throws com.liferay.portal.kernel.exception.SystemException {
8485                    return getPersistence()
8486                                       .fetchByC_V_ST_Last(companyId, version, status,
8487                            orderByComparator);
8488            }
8489    
8490            /**
8491            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
8492            *
8493            * @param id the primary key of the current journal article
8494            * @param companyId the company ID
8495            * @param version the version
8496            * @param status the status
8497            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8498            * @return the previous, current, and next journal article
8499            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8500            * @throws SystemException if a system exception occurred
8501            */
8502            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
8503                    long id, long companyId, double version, int status,
8504                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8505                    throws com.liferay.portal.kernel.exception.SystemException,
8506                            com.liferay.portlet.journal.NoSuchArticleException {
8507                    return getPersistence()
8508                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
8509                            orderByComparator);
8510            }
8511    
8512            /**
8513            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
8514            *
8515            * @param companyId the company ID
8516            * @param version the version
8517            * @param status the status
8518            * @throws SystemException if a system exception occurred
8519            */
8520            public static void removeByC_V_ST(long companyId, double version, int status)
8521                    throws com.liferay.portal.kernel.exception.SystemException {
8522                    getPersistence().removeByC_V_ST(companyId, version, status);
8523            }
8524    
8525            /**
8526            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8527            *
8528            * @param companyId the company ID
8529            * @param version the version
8530            * @param status the status
8531            * @return the number of matching journal articles
8532            * @throws SystemException if a system exception occurred
8533            */
8534            public static int countByC_V_ST(long companyId, double version, int status)
8535                    throws com.liferay.portal.kernel.exception.SystemException {
8536                    return getPersistence().countByC_V_ST(companyId, version, status);
8537            }
8538    
8539            /**
8540            * Caches the journal article in the entity cache if it is enabled.
8541            *
8542            * @param journalArticle the journal article
8543            */
8544            public static void cacheResult(
8545                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
8546                    getPersistence().cacheResult(journalArticle);
8547            }
8548    
8549            /**
8550            * Caches the journal articles in the entity cache if it is enabled.
8551            *
8552            * @param journalArticles the journal articles
8553            */
8554            public static void cacheResult(
8555                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
8556                    getPersistence().cacheResult(journalArticles);
8557            }
8558    
8559            /**
8560            * Creates a new journal article with the primary key. Does not add the journal article to the database.
8561            *
8562            * @param id the primary key for the new journal article
8563            * @return the new journal article
8564            */
8565            public static com.liferay.portlet.journal.model.JournalArticle create(
8566                    long id) {
8567                    return getPersistence().create(id);
8568            }
8569    
8570            /**
8571            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
8572            *
8573            * @param id the primary key of the journal article
8574            * @return the journal article that was removed
8575            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8576            * @throws SystemException if a system exception occurred
8577            */
8578            public static com.liferay.portlet.journal.model.JournalArticle remove(
8579                    long id)
8580                    throws com.liferay.portal.kernel.exception.SystemException,
8581                            com.liferay.portlet.journal.NoSuchArticleException {
8582                    return getPersistence().remove(id);
8583            }
8584    
8585            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
8586                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
8587                    throws com.liferay.portal.kernel.exception.SystemException {
8588                    return getPersistence().updateImpl(journalArticle);
8589            }
8590    
8591            /**
8592            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
8593            *
8594            * @param id the primary key of the journal article
8595            * @return the journal article
8596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8597            * @throws SystemException if a system exception occurred
8598            */
8599            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
8600                    long id)
8601                    throws com.liferay.portal.kernel.exception.SystemException,
8602                            com.liferay.portlet.journal.NoSuchArticleException {
8603                    return getPersistence().findByPrimaryKey(id);
8604            }
8605    
8606            /**
8607            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
8608            *
8609            * @param id the primary key of the journal article
8610            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
8611            * @throws SystemException if a system exception occurred
8612            */
8613            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
8614                    long id) throws com.liferay.portal.kernel.exception.SystemException {
8615                    return getPersistence().fetchByPrimaryKey(id);
8616            }
8617    
8618            /**
8619            * Returns all the journal articles.
8620            *
8621            * @return the journal articles
8622            * @throws SystemException if a system exception occurred
8623            */
8624            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
8625                    throws com.liferay.portal.kernel.exception.SystemException {
8626                    return getPersistence().findAll();
8627            }
8628    
8629            /**
8630            * Returns a range of all the journal articles.
8631            *
8632            * <p>
8633            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8634            * </p>
8635            *
8636            * @param start the lower bound of the range of journal articles
8637            * @param end the upper bound of the range of journal articles (not inclusive)
8638            * @return the range of journal articles
8639            * @throws SystemException if a system exception occurred
8640            */
8641            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
8642                    int start, int end)
8643                    throws com.liferay.portal.kernel.exception.SystemException {
8644                    return getPersistence().findAll(start, end);
8645            }
8646    
8647            /**
8648            * Returns an ordered range of all the journal articles.
8649            *
8650            * <p>
8651            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8652            * </p>
8653            *
8654            * @param start the lower bound of the range of journal articles
8655            * @param end the upper bound of the range of journal articles (not inclusive)
8656            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8657            * @return the ordered range of journal articles
8658            * @throws SystemException if a system exception occurred
8659            */
8660            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
8661                    int start, int end,
8662                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8663                    throws com.liferay.portal.kernel.exception.SystemException {
8664                    return getPersistence().findAll(start, end, orderByComparator);
8665            }
8666    
8667            /**
8668            * Removes all the journal articles from the database.
8669            *
8670            * @throws SystemException if a system exception occurred
8671            */
8672            public static void removeAll()
8673                    throws com.liferay.portal.kernel.exception.SystemException {
8674                    getPersistence().removeAll();
8675            }
8676    
8677            /**
8678            * Returns the number of journal articles.
8679            *
8680            * @return the number of journal articles
8681            * @throws SystemException if a system exception occurred
8682            */
8683            public static int countAll()
8684                    throws com.liferay.portal.kernel.exception.SystemException {
8685                    return getPersistence().countAll();
8686            }
8687    
8688            public static JournalArticlePersistence getPersistence() {
8689                    if (_persistence == null) {
8690                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
8691    
8692                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
8693                                    "_persistence");
8694                    }
8695    
8696                    return _persistence;
8697            }
8698    
8699            /**
8700             * @deprecated As of 6.2.0
8701             */
8702            public void setPersistence(JournalArticlePersistence persistence) {
8703            }
8704    
8705            private static JournalArticlePersistence _persistence;
8706    }