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