001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.util.OrderByComparator;
023    import com.liferay.portal.kernel.util.ReferenceRegistry;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import com.liferay.portlet.journal.model.JournalArticle;
027    
028    import java.util.List;
029    
030    /**
031     * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
032     *
033     * <p>
034     * Caching information and settings can be found in <code>portal.properties</code>
035     * </p>
036     *
037     * @author Brian Wing Shun Chan
038     * @see JournalArticlePersistence
039     * @see JournalArticlePersistenceImpl
040     * @generated
041     */
042    @ProviderType
043    public class JournalArticleUtil {
044            /*
045             * NOTE FOR DEVELOPERS:
046             *
047             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
048             */
049    
050            /**
051             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
052             */
053            public static void clearCache() {
054                    getPersistence().clearCache();
055            }
056    
057            /**
058             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
059             */
060            public static void clearCache(JournalArticle journalArticle) {
061                    getPersistence().clearCache(journalArticle);
062            }
063    
064            /**
065             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
066             */
067            public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
068                    throws SystemException {
069                    return getPersistence().countWithDynamicQuery(dynamicQuery);
070            }
071    
072            /**
073             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
074             */
075            public static List<JournalArticle> findWithDynamicQuery(
076                    DynamicQuery dynamicQuery) throws SystemException {
077                    return getPersistence().findWithDynamicQuery(dynamicQuery);
078            }
079    
080            /**
081             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
082             */
083            public static List<JournalArticle> findWithDynamicQuery(
084                    DynamicQuery dynamicQuery, int start, int end)
085                    throws SystemException {
086                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
087            }
088    
089            /**
090             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
091             */
092            public static List<JournalArticle> findWithDynamicQuery(
093                    DynamicQuery dynamicQuery, int start, int end,
094                    OrderByComparator orderByComparator) throws SystemException {
095                    return getPersistence()
096                                       .findWithDynamicQuery(dynamicQuery, start, end,
097                            orderByComparator);
098            }
099    
100            /**
101             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
102             */
103            public static JournalArticle update(JournalArticle journalArticle)
104                    throws SystemException {
105                    return getPersistence().update(journalArticle);
106            }
107    
108            /**
109             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
110             */
111            public static JournalArticle update(JournalArticle journalArticle,
112                    ServiceContext serviceContext) throws SystemException {
113                    return getPersistence().update(journalArticle, serviceContext);
114            }
115    
116            /**
117            * Returns all the journal articles where uuid = &#63;.
118            *
119            * @param uuid the uuid
120            * @return the matching journal articles
121            * @throws SystemException if a system exception occurred
122            */
123            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
124                    java.lang.String uuid)
125                    throws com.liferay.portal.kernel.exception.SystemException {
126                    return getPersistence().findByUuid(uuid);
127            }
128    
129            /**
130            * Returns a range of all the journal articles where uuid = &#63;.
131            *
132            * <p>
133            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
134            * </p>
135            *
136            * @param uuid the uuid
137            * @param start the lower bound of the range of journal articles
138            * @param end the upper bound of the range of journal articles (not inclusive)
139            * @return the range of matching journal articles
140            * @throws SystemException if a system exception occurred
141            */
142            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
143                    java.lang.String uuid, int start, int end)
144                    throws com.liferay.portal.kernel.exception.SystemException {
145                    return getPersistence().findByUuid(uuid, start, end);
146            }
147    
148            /**
149            * Returns an ordered range of all the journal articles where uuid = &#63;.
150            *
151            * <p>
152            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
153            * </p>
154            *
155            * @param uuid the uuid
156            * @param start the lower bound of the range of journal articles
157            * @param end the upper bound of the range of journal articles (not inclusive)
158            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
159            * @return the ordered range of matching journal articles
160            * @throws SystemException if a system exception occurred
161            */
162            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
163                    java.lang.String uuid, int start, int end,
164                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
165                    throws com.liferay.portal.kernel.exception.SystemException {
166                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
167            }
168    
169            /**
170            * Returns the first journal article in the ordered set where uuid = &#63;.
171            *
172            * @param uuid the uuid
173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
174            * @return the first matching journal article
175            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
176            * @throws SystemException if a system exception occurred
177            */
178            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
179                    java.lang.String uuid,
180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
181                    throws com.liferay.portal.kernel.exception.SystemException,
182                            com.liferay.portlet.journal.NoSuchArticleException {
183                    return getPersistence().findByUuid_First(uuid, orderByComparator);
184            }
185    
186            /**
187            * Returns the first journal article in the ordered set where uuid = &#63;.
188            *
189            * @param uuid the uuid
190            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
191            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
192            * @throws SystemException if a system exception occurred
193            */
194            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First(
195                    java.lang.String uuid,
196                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
197                    throws com.liferay.portal.kernel.exception.SystemException {
198                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
199            }
200    
201            /**
202            * Returns the last journal article in the ordered set where uuid = &#63;.
203            *
204            * @param uuid the uuid
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the last matching journal article
207            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
208            * @throws SystemException if a system exception occurred
209            */
210            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
211                    java.lang.String uuid,
212                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
213                    throws com.liferay.portal.kernel.exception.SystemException,
214                            com.liferay.portlet.journal.NoSuchArticleException {
215                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
216            }
217    
218            /**
219            * Returns the last journal article in the ordered set where uuid = &#63;.
220            *
221            * @param uuid the uuid
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
224            * @throws SystemException if a system exception occurred
225            */
226            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last(
227                    java.lang.String uuid,
228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
229                    throws com.liferay.portal.kernel.exception.SystemException {
230                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
231            }
232    
233            /**
234            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
235            *
236            * @param id the primary key of the current journal article
237            * @param uuid the uuid
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next journal article
240            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
241            * @throws SystemException if a system exception occurred
242            */
243            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
244                    long id, java.lang.String uuid,
245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
246                    throws com.liferay.portal.kernel.exception.SystemException,
247                            com.liferay.portlet.journal.NoSuchArticleException {
248                    return getPersistence()
249                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
250            }
251    
252            /**
253            * Removes all the journal articles where uuid = &#63; from the database.
254            *
255            * @param uuid the uuid
256            * @throws SystemException if a system exception occurred
257            */
258            public static void removeByUuid(java.lang.String uuid)
259                    throws com.liferay.portal.kernel.exception.SystemException {
260                    getPersistence().removeByUuid(uuid);
261            }
262    
263            /**
264            * Returns the number of journal articles where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @return the number of matching journal articles
268            * @throws SystemException if a system exception occurred
269            */
270            public static int countByUuid(java.lang.String uuid)
271                    throws com.liferay.portal.kernel.exception.SystemException {
272                    return getPersistence().countByUuid(uuid);
273            }
274    
275            /**
276            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
277            *
278            * @param uuid the uuid
279            * @param groupId the group ID
280            * @return the matching journal article
281            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
282            * @throws SystemException if a system exception occurred
283            */
284            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
285                    java.lang.String uuid, long groupId)
286                    throws com.liferay.portal.kernel.exception.SystemException,
287                            com.liferay.portlet.journal.NoSuchArticleException {
288                    return getPersistence().findByUUID_G(uuid, groupId);
289            }
290    
291            /**
292            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
293            *
294            * @param uuid the uuid
295            * @param groupId the group ID
296            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
297            * @throws SystemException if a system exception occurred
298            */
299            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
300                    java.lang.String uuid, long groupId)
301                    throws com.liferay.portal.kernel.exception.SystemException {
302                    return getPersistence().fetchByUUID_G(uuid, groupId);
303            }
304    
305            /**
306            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
307            *
308            * @param uuid the uuid
309            * @param groupId the group ID
310            * @param retrieveFromCache whether to use the finder cache
311            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
312            * @throws SystemException if a system exception occurred
313            */
314            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
315                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
316                    throws com.liferay.portal.kernel.exception.SystemException {
317                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
318            }
319    
320            /**
321            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
322            *
323            * @param uuid the uuid
324            * @param groupId the group ID
325            * @return the journal article that was removed
326            * @throws SystemException if a system exception occurred
327            */
328            public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G(
329                    java.lang.String uuid, long groupId)
330                    throws com.liferay.portal.kernel.exception.SystemException,
331                            com.liferay.portlet.journal.NoSuchArticleException {
332                    return getPersistence().removeByUUID_G(uuid, groupId);
333            }
334    
335            /**
336            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
337            *
338            * @param uuid the uuid
339            * @param groupId the group ID
340            * @return the number of matching journal articles
341            * @throws SystemException if a system exception occurred
342            */
343            public static int countByUUID_G(java.lang.String uuid, long groupId)
344                    throws com.liferay.portal.kernel.exception.SystemException {
345                    return getPersistence().countByUUID_G(uuid, groupId);
346            }
347    
348            /**
349            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
350            *
351            * @param uuid the uuid
352            * @param companyId the company ID
353            * @return the matching journal articles
354            * @throws SystemException if a system exception occurred
355            */
356            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
357                    java.lang.String uuid, long companyId)
358                    throws com.liferay.portal.kernel.exception.SystemException {
359                    return getPersistence().findByUuid_C(uuid, companyId);
360            }
361    
362            /**
363            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
364            *
365            * <p>
366            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
367            * </p>
368            *
369            * @param uuid the uuid
370            * @param companyId the company ID
371            * @param start the lower bound of the range of journal articles
372            * @param end the upper bound of the range of journal articles (not inclusive)
373            * @return the range of matching journal articles
374            * @throws SystemException if a system exception occurred
375            */
376            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
377                    java.lang.String uuid, long companyId, int start, int end)
378                    throws com.liferay.portal.kernel.exception.SystemException {
379                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
380            }
381    
382            /**
383            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
384            *
385            * <p>
386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
387            * </p>
388            *
389            * @param uuid the uuid
390            * @param companyId the company ID
391            * @param start the lower bound of the range of journal articles
392            * @param end the upper bound of the range of journal articles (not inclusive)
393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
394            * @return the ordered range of matching journal articles
395            * @throws SystemException if a system exception occurred
396            */
397            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
398                    java.lang.String uuid, long companyId, int start, int end,
399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
400                    throws com.liferay.portal.kernel.exception.SystemException {
401                    return getPersistence()
402                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
403            }
404    
405            /**
406            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the first matching journal article
412            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
413            * @throws SystemException if a system exception occurred
414            */
415            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First(
416                    java.lang.String uuid, long companyId,
417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
418                    throws com.liferay.portal.kernel.exception.SystemException,
419                            com.liferay.portlet.journal.NoSuchArticleException {
420                    return getPersistence()
421                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
422            }
423    
424            /**
425            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
426            *
427            * @param uuid the uuid
428            * @param companyId the company ID
429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
430            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
431            * @throws SystemException if a system exception occurred
432            */
433            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First(
434                    java.lang.String uuid, long companyId,
435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
436                    throws com.liferay.portal.kernel.exception.SystemException {
437                    return getPersistence()
438                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
439            }
440    
441            /**
442            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
443            *
444            * @param uuid the uuid
445            * @param companyId the company ID
446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
447            * @return the last matching journal article
448            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
449            * @throws SystemException if a system exception occurred
450            */
451            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last(
452                    java.lang.String uuid, long companyId,
453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.journal.NoSuchArticleException {
456                    return getPersistence()
457                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
458            }
459    
460            /**
461            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
462            *
463            * @param uuid the uuid
464            * @param companyId the company ID
465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
466            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
467            * @throws SystemException if a system exception occurred
468            */
469            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last(
470                    java.lang.String uuid, long companyId,
471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
472                    throws com.liferay.portal.kernel.exception.SystemException {
473                    return getPersistence()
474                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
475            }
476    
477            /**
478            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
479            *
480            * @param id the primary key of the current journal article
481            * @param uuid the uuid
482            * @param companyId the company ID
483            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
484            * @return the previous, current, and next journal article
485            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
486            * @throws SystemException if a system exception occurred
487            */
488            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext(
489                    long id, java.lang.String uuid, long companyId,
490                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
491                    throws com.liferay.portal.kernel.exception.SystemException,
492                            com.liferay.portlet.journal.NoSuchArticleException {
493                    return getPersistence()
494                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
495                            orderByComparator);
496            }
497    
498            /**
499            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
500            *
501            * @param uuid the uuid
502            * @param companyId the company ID
503            * @throws SystemException if a system exception occurred
504            */
505            public static void removeByUuid_C(java.lang.String uuid, long companyId)
506                    throws com.liferay.portal.kernel.exception.SystemException {
507                    getPersistence().removeByUuid_C(uuid, companyId);
508            }
509    
510            /**
511            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
512            *
513            * @param uuid the uuid
514            * @param companyId the company ID
515            * @return the number of matching journal articles
516            * @throws SystemException if a system exception occurred
517            */
518            public static int countByUuid_C(java.lang.String uuid, long companyId)
519                    throws com.liferay.portal.kernel.exception.SystemException {
520                    return getPersistence().countByUuid_C(uuid, companyId);
521            }
522    
523            /**
524            * Returns all the journal articles where resourcePrimKey = &#63;.
525            *
526            * @param resourcePrimKey the resource prim key
527            * @return the matching journal articles
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
531                    long resourcePrimKey)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
534            }
535    
536            /**
537            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
538            *
539            * <p>
540            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
541            * </p>
542            *
543            * @param resourcePrimKey the resource prim key
544            * @param start the lower bound of the range of journal articles
545            * @param end the upper bound of the range of journal articles (not inclusive)
546            * @return the range of matching journal articles
547            * @throws SystemException if a system exception occurred
548            */
549            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
550                    long resourcePrimKey, int start, int end)
551                    throws com.liferay.portal.kernel.exception.SystemException {
552                    return getPersistence()
553                                       .findByResourcePrimKey(resourcePrimKey, start, end);
554            }
555    
556            /**
557            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
558            *
559            * <p>
560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
561            * </p>
562            *
563            * @param resourcePrimKey the resource prim key
564            * @param start the lower bound of the range of journal articles
565            * @param end the upper bound of the range of journal articles (not inclusive)
566            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
567            * @return the ordered range of matching journal articles
568            * @throws SystemException if a system exception occurred
569            */
570            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
571                    long resourcePrimKey, int start, int end,
572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
573                    throws com.liferay.portal.kernel.exception.SystemException {
574                    return getPersistence()
575                                       .findByResourcePrimKey(resourcePrimKey, start, end,
576                            orderByComparator);
577            }
578    
579            /**
580            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
581            *
582            * @param resourcePrimKey the resource prim key
583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
584            * @return the first matching journal article
585            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
586            * @throws SystemException if a system exception occurred
587            */
588            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
589                    long resourcePrimKey,
590                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
591                    throws com.liferay.portal.kernel.exception.SystemException,
592                            com.liferay.portlet.journal.NoSuchArticleException {
593                    return getPersistence()
594                                       .findByResourcePrimKey_First(resourcePrimKey,
595                            orderByComparator);
596            }
597    
598            /**
599            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
600            *
601            * @param resourcePrimKey the resource prim key
602            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
603            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
604            * @throws SystemException if a system exception occurred
605            */
606            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First(
607                    long resourcePrimKey,
608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
609                    throws com.liferay.portal.kernel.exception.SystemException {
610                    return getPersistence()
611                                       .fetchByResourcePrimKey_First(resourcePrimKey,
612                            orderByComparator);
613            }
614    
615            /**
616            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
617            *
618            * @param resourcePrimKey the resource prim key
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the last matching journal article
621            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
622            * @throws SystemException if a system exception occurred
623            */
624            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
625                    long resourcePrimKey,
626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
627                    throws com.liferay.portal.kernel.exception.SystemException,
628                            com.liferay.portlet.journal.NoSuchArticleException {
629                    return getPersistence()
630                                       .findByResourcePrimKey_Last(resourcePrimKey,
631                            orderByComparator);
632            }
633    
634            /**
635            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
636            *
637            * @param resourcePrimKey the resource prim key
638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
639            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
640            * @throws SystemException if a system exception occurred
641            */
642            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last(
643                    long resourcePrimKey,
644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
645                    throws com.liferay.portal.kernel.exception.SystemException {
646                    return getPersistence()
647                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
648                            orderByComparator);
649            }
650    
651            /**
652            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
653            *
654            * @param id the primary key of the current journal article
655            * @param resourcePrimKey the resource prim key
656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
657            * @return the previous, current, and next journal article
658            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
659            * @throws SystemException if a system exception occurred
660            */
661            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
662                    long id, long resourcePrimKey,
663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
664                    throws com.liferay.portal.kernel.exception.SystemException,
665                            com.liferay.portlet.journal.NoSuchArticleException {
666                    return getPersistence()
667                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
668                            orderByComparator);
669            }
670    
671            /**
672            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
673            *
674            * @param resourcePrimKey the resource prim key
675            * @throws SystemException if a system exception occurred
676            */
677            public static void removeByResourcePrimKey(long resourcePrimKey)
678                    throws com.liferay.portal.kernel.exception.SystemException {
679                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
680            }
681    
682            /**
683            * Returns the number of journal articles where resourcePrimKey = &#63;.
684            *
685            * @param resourcePrimKey the resource prim key
686            * @return the number of matching journal articles
687            * @throws SystemException if a system exception occurred
688            */
689            public static int countByResourcePrimKey(long resourcePrimKey)
690                    throws com.liferay.portal.kernel.exception.SystemException {
691                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
692            }
693    
694            /**
695            * Returns all the journal articles where groupId = &#63;.
696            *
697            * @param groupId the group ID
698            * @return the matching journal articles
699            * @throws SystemException if a system exception occurred
700            */
701            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
702                    long groupId)
703                    throws com.liferay.portal.kernel.exception.SystemException {
704                    return getPersistence().findByGroupId(groupId);
705            }
706    
707            /**
708            * Returns a range of all the journal articles where groupId = &#63;.
709            *
710            * <p>
711            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
712            * </p>
713            *
714            * @param groupId the group ID
715            * @param start the lower bound of the range of journal articles
716            * @param end the upper bound of the range of journal articles (not inclusive)
717            * @return the range of matching journal articles
718            * @throws SystemException if a system exception occurred
719            */
720            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
721                    long groupId, int start, int end)
722                    throws com.liferay.portal.kernel.exception.SystemException {
723                    return getPersistence().findByGroupId(groupId, start, end);
724            }
725    
726            /**
727            * Returns an ordered range of all the journal articles where groupId = &#63;.
728            *
729            * <p>
730            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
731            * </p>
732            *
733            * @param groupId the group ID
734            * @param start the lower bound of the range of journal articles
735            * @param end the upper bound of the range of journal articles (not inclusive)
736            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
737            * @return the ordered range of matching journal articles
738            * @throws SystemException if a system exception occurred
739            */
740            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
741                    long groupId, int start, int end,
742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
743                    throws com.liferay.portal.kernel.exception.SystemException {
744                    return getPersistence()
745                                       .findByGroupId(groupId, start, end, orderByComparator);
746            }
747    
748            /**
749            * Returns the first journal article in the ordered set where groupId = &#63;.
750            *
751            * @param groupId the group ID
752            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
753            * @return the first matching journal article
754            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
755            * @throws SystemException if a system exception occurred
756            */
757            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
758                    long groupId,
759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
760                    throws com.liferay.portal.kernel.exception.SystemException,
761                            com.liferay.portlet.journal.NoSuchArticleException {
762                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
763            }
764    
765            /**
766            * Returns the first journal article in the ordered set where groupId = &#63;.
767            *
768            * @param groupId the group ID
769            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
770            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
771            * @throws SystemException if a system exception occurred
772            */
773            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First(
774                    long groupId,
775                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
778            }
779    
780            /**
781            * Returns the last journal article in the ordered set where groupId = &#63;.
782            *
783            * @param groupId the group ID
784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
785            * @return the last matching journal article
786            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
787            * @throws SystemException if a system exception occurred
788            */
789            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
790                    long groupId,
791                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
792                    throws com.liferay.portal.kernel.exception.SystemException,
793                            com.liferay.portlet.journal.NoSuchArticleException {
794                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
795            }
796    
797            /**
798            * Returns the last journal article in the ordered set where groupId = &#63;.
799            *
800            * @param groupId the group ID
801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
802            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
803            * @throws SystemException if a system exception occurred
804            */
805            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last(
806                    long groupId,
807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
808                    throws com.liferay.portal.kernel.exception.SystemException {
809                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
810            }
811    
812            /**
813            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
814            *
815            * @param id the primary key of the current journal article
816            * @param groupId the group ID
817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
818            * @return the previous, current, and next journal article
819            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
820            * @throws SystemException if a system exception occurred
821            */
822            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
823                    long id, long groupId,
824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
825                    throws com.liferay.portal.kernel.exception.SystemException,
826                            com.liferay.portlet.journal.NoSuchArticleException {
827                    return getPersistence()
828                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
829            }
830    
831            /**
832            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
833            *
834            * @param groupId the group ID
835            * @return the matching journal articles that the user has permission to view
836            * @throws SystemException if a system exception occurred
837            */
838            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
839                    long groupId)
840                    throws com.liferay.portal.kernel.exception.SystemException {
841                    return getPersistence().filterFindByGroupId(groupId);
842            }
843    
844            /**
845            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
846            *
847            * <p>
848            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
849            * </p>
850            *
851            * @param groupId the group ID
852            * @param start the lower bound of the range of journal articles
853            * @param end the upper bound of the range of journal articles (not inclusive)
854            * @return the range of matching journal articles that the user has permission to view
855            * @throws SystemException if a system exception occurred
856            */
857            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
858                    long groupId, int start, int end)
859                    throws com.liferay.portal.kernel.exception.SystemException {
860                    return getPersistence().filterFindByGroupId(groupId, start, end);
861            }
862    
863            /**
864            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
865            *
866            * <p>
867            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
868            * </p>
869            *
870            * @param groupId the group ID
871            * @param start the lower bound of the range of journal articles
872            * @param end the upper bound of the range of journal articles (not inclusive)
873            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
874            * @return the ordered range of matching journal articles that the user has permission to view
875            * @throws SystemException if a system exception occurred
876            */
877            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
878                    long groupId, int start, int end,
879                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
880                    throws com.liferay.portal.kernel.exception.SystemException {
881                    return getPersistence()
882                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
883            }
884    
885            /**
886            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63;.
887            *
888            * @param id the primary key of the current journal article
889            * @param groupId the group ID
890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
891            * @return the previous, current, and next journal article
892            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
893            * @throws SystemException if a system exception occurred
894            */
895            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
896                    long id, long groupId,
897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
898                    throws com.liferay.portal.kernel.exception.SystemException,
899                            com.liferay.portlet.journal.NoSuchArticleException {
900                    return getPersistence()
901                                       .filterFindByGroupId_PrevAndNext(id, groupId,
902                            orderByComparator);
903            }
904    
905            /**
906            * Removes all the journal articles where groupId = &#63; from the database.
907            *
908            * @param groupId the group ID
909            * @throws SystemException if a system exception occurred
910            */
911            public static void removeByGroupId(long groupId)
912                    throws com.liferay.portal.kernel.exception.SystemException {
913                    getPersistence().removeByGroupId(groupId);
914            }
915    
916            /**
917            * Returns the number of journal articles where groupId = &#63;.
918            *
919            * @param groupId the group ID
920            * @return the number of matching journal articles
921            * @throws SystemException if a system exception occurred
922            */
923            public static int countByGroupId(long groupId)
924                    throws com.liferay.portal.kernel.exception.SystemException {
925                    return getPersistence().countByGroupId(groupId);
926            }
927    
928            /**
929            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
930            *
931            * @param groupId the group ID
932            * @return the number of matching journal articles that the user has permission to view
933            * @throws SystemException if a system exception occurred
934            */
935            public static int filterCountByGroupId(long groupId)
936                    throws com.liferay.portal.kernel.exception.SystemException {
937                    return getPersistence().filterCountByGroupId(groupId);
938            }
939    
940            /**
941            * Returns all the journal articles where companyId = &#63;.
942            *
943            * @param companyId the company ID
944            * @return the matching journal articles
945            * @throws SystemException if a system exception occurred
946            */
947            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
948                    long companyId)
949                    throws com.liferay.portal.kernel.exception.SystemException {
950                    return getPersistence().findByCompanyId(companyId);
951            }
952    
953            /**
954            * Returns a range of all the journal articles where companyId = &#63;.
955            *
956            * <p>
957            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
958            * </p>
959            *
960            * @param companyId the company ID
961            * @param start the lower bound of the range of journal articles
962            * @param end the upper bound of the range of journal articles (not inclusive)
963            * @return the range of matching journal articles
964            * @throws SystemException if a system exception occurred
965            */
966            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
967                    long companyId, int start, int end)
968                    throws com.liferay.portal.kernel.exception.SystemException {
969                    return getPersistence().findByCompanyId(companyId, start, end);
970            }
971    
972            /**
973            * Returns an ordered range of all the journal articles where companyId = &#63;.
974            *
975            * <p>
976            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
977            * </p>
978            *
979            * @param companyId the company ID
980            * @param start the lower bound of the range of journal articles
981            * @param end the upper bound of the range of journal articles (not inclusive)
982            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
983            * @return the ordered range of matching journal articles
984            * @throws SystemException if a system exception occurred
985            */
986            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
987                    long companyId, int start, int end,
988                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
989                    throws com.liferay.portal.kernel.exception.SystemException {
990                    return getPersistence()
991                                       .findByCompanyId(companyId, start, end, orderByComparator);
992            }
993    
994            /**
995            * Returns the first journal article in the ordered set where companyId = &#63;.
996            *
997            * @param companyId the company ID
998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
999            * @return the first matching journal article
1000            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1001            * @throws SystemException if a system exception occurred
1002            */
1003            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
1004                    long companyId,
1005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1006                    throws com.liferay.portal.kernel.exception.SystemException,
1007                            com.liferay.portlet.journal.NoSuchArticleException {
1008                    return getPersistence()
1009                                       .findByCompanyId_First(companyId, orderByComparator);
1010            }
1011    
1012            /**
1013            * Returns the first journal article in the ordered set where companyId = &#63;.
1014            *
1015            * @param companyId the company ID
1016            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1017            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1018            * @throws SystemException if a system exception occurred
1019            */
1020            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First(
1021                    long companyId,
1022                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1023                    throws com.liferay.portal.kernel.exception.SystemException {
1024                    return getPersistence()
1025                                       .fetchByCompanyId_First(companyId, orderByComparator);
1026            }
1027    
1028            /**
1029            * Returns the last journal article in the ordered set where companyId = &#63;.
1030            *
1031            * @param companyId the company ID
1032            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1033            * @return the last matching journal article
1034            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1035            * @throws SystemException if a system exception occurred
1036            */
1037            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
1038                    long companyId,
1039                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1040                    throws com.liferay.portal.kernel.exception.SystemException,
1041                            com.liferay.portlet.journal.NoSuchArticleException {
1042                    return getPersistence()
1043                                       .findByCompanyId_Last(companyId, orderByComparator);
1044            }
1045    
1046            /**
1047            * Returns the last journal article in the ordered set where companyId = &#63;.
1048            *
1049            * @param companyId the company ID
1050            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1051            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1052            * @throws SystemException if a system exception occurred
1053            */
1054            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last(
1055                    long companyId,
1056                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1057                    throws com.liferay.portal.kernel.exception.SystemException {
1058                    return getPersistence()
1059                                       .fetchByCompanyId_Last(companyId, orderByComparator);
1060            }
1061    
1062            /**
1063            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
1064            *
1065            * @param id the primary key of the current journal article
1066            * @param companyId the company ID
1067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1068            * @return the previous, current, and next journal article
1069            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
1073                    long id, long companyId,
1074                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1075                    throws com.liferay.portal.kernel.exception.SystemException,
1076                            com.liferay.portlet.journal.NoSuchArticleException {
1077                    return getPersistence()
1078                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
1079            }
1080    
1081            /**
1082            * Removes all the journal articles where companyId = &#63; from the database.
1083            *
1084            * @param companyId the company ID
1085            * @throws SystemException if a system exception occurred
1086            */
1087            public static void removeByCompanyId(long companyId)
1088                    throws com.liferay.portal.kernel.exception.SystemException {
1089                    getPersistence().removeByCompanyId(companyId);
1090            }
1091    
1092            /**
1093            * Returns the number of journal articles where companyId = &#63;.
1094            *
1095            * @param companyId the company ID
1096            * @return the number of matching journal articles
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static int countByCompanyId(long companyId)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    return getPersistence().countByCompanyId(companyId);
1102            }
1103    
1104            /**
1105            * Returns all the journal articles where structureId = &#63;.
1106            *
1107            * @param structureId the structure ID
1108            * @return the matching journal articles
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1112                    java.lang.String structureId)
1113                    throws com.liferay.portal.kernel.exception.SystemException {
1114                    return getPersistence().findByStructureId(structureId);
1115            }
1116    
1117            /**
1118            * Returns a range of all the journal articles where structureId = &#63;.
1119            *
1120            * <p>
1121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1122            * </p>
1123            *
1124            * @param structureId the structure ID
1125            * @param start the lower bound of the range of journal articles
1126            * @param end the upper bound of the range of journal articles (not inclusive)
1127            * @return the range of matching journal articles
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1131                    java.lang.String structureId, int start, int end)
1132                    throws com.liferay.portal.kernel.exception.SystemException {
1133                    return getPersistence().findByStructureId(structureId, start, end);
1134            }
1135    
1136            /**
1137            * Returns an ordered range of all the journal articles where structureId = &#63;.
1138            *
1139            * <p>
1140            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1141            * </p>
1142            *
1143            * @param structureId the structure ID
1144            * @param start the lower bound of the range of journal articles
1145            * @param end the upper bound of the range of journal articles (not inclusive)
1146            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1147            * @return the ordered range of matching journal articles
1148            * @throws SystemException if a system exception occurred
1149            */
1150            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1151                    java.lang.String structureId, int start, int end,
1152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1153                    throws com.liferay.portal.kernel.exception.SystemException {
1154                    return getPersistence()
1155                                       .findByStructureId(structureId, start, end, orderByComparator);
1156            }
1157    
1158            /**
1159            * Returns the first journal article in the ordered set where structureId = &#63;.
1160            *
1161            * @param structureId the structure ID
1162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1163            * @return the first matching journal article
1164            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1165            * @throws SystemException if a system exception occurred
1166            */
1167            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
1168                    java.lang.String structureId,
1169                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1170                    throws com.liferay.portal.kernel.exception.SystemException,
1171                            com.liferay.portlet.journal.NoSuchArticleException {
1172                    return getPersistence()
1173                                       .findByStructureId_First(structureId, orderByComparator);
1174            }
1175    
1176            /**
1177            * Returns the first journal article in the ordered set where structureId = &#63;.
1178            *
1179            * @param structureId the structure ID
1180            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1181            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First(
1185                    java.lang.String structureId,
1186                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1187                    throws com.liferay.portal.kernel.exception.SystemException {
1188                    return getPersistence()
1189                                       .fetchByStructureId_First(structureId, orderByComparator);
1190            }
1191    
1192            /**
1193            * Returns the last journal article in the ordered set where structureId = &#63;.
1194            *
1195            * @param structureId the structure ID
1196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1197            * @return the last matching journal article
1198            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1199            * @throws SystemException if a system exception occurred
1200            */
1201            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
1202                    java.lang.String structureId,
1203                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1204                    throws com.liferay.portal.kernel.exception.SystemException,
1205                            com.liferay.portlet.journal.NoSuchArticleException {
1206                    return getPersistence()
1207                                       .findByStructureId_Last(structureId, orderByComparator);
1208            }
1209    
1210            /**
1211            * Returns the last journal article in the ordered set where structureId = &#63;.
1212            *
1213            * @param structureId the structure ID
1214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1215            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1216            * @throws SystemException if a system exception occurred
1217            */
1218            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last(
1219                    java.lang.String structureId,
1220                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1221                    throws com.liferay.portal.kernel.exception.SystemException {
1222                    return getPersistence()
1223                                       .fetchByStructureId_Last(structureId, orderByComparator);
1224            }
1225    
1226            /**
1227            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
1228            *
1229            * @param id the primary key of the current journal article
1230            * @param structureId the structure ID
1231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1232            * @return the previous, current, and next journal article
1233            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1234            * @throws SystemException if a system exception occurred
1235            */
1236            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
1237                    long id, java.lang.String structureId,
1238                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1239                    throws com.liferay.portal.kernel.exception.SystemException,
1240                            com.liferay.portlet.journal.NoSuchArticleException {
1241                    return getPersistence()
1242                                       .findByStructureId_PrevAndNext(id, structureId,
1243                            orderByComparator);
1244            }
1245    
1246            /**
1247            * Returns all the journal articles where structureId = any &#63;.
1248            *
1249            * <p>
1250            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1251            * </p>
1252            *
1253            * @param structureIds the structure IDs
1254            * @return the matching journal articles
1255            * @throws SystemException if a system exception occurred
1256            */
1257            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1258                    java.lang.String[] structureIds)
1259                    throws com.liferay.portal.kernel.exception.SystemException {
1260                    return getPersistence().findByStructureId(structureIds);
1261            }
1262    
1263            /**
1264            * Returns a range of all the journal articles where structureId = any &#63;.
1265            *
1266            * <p>
1267            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1268            * </p>
1269            *
1270            * @param structureIds the structure IDs
1271            * @param start the lower bound of the range of journal articles
1272            * @param end the upper bound of the range of journal articles (not inclusive)
1273            * @return the range of matching journal articles
1274            * @throws SystemException if a system exception occurred
1275            */
1276            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1277                    java.lang.String[] structureIds, int start, int end)
1278                    throws com.liferay.portal.kernel.exception.SystemException {
1279                    return getPersistence().findByStructureId(structureIds, start, end);
1280            }
1281    
1282            /**
1283            * Returns an ordered range of all the journal articles where structureId = any &#63;.
1284            *
1285            * <p>
1286            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1287            * </p>
1288            *
1289            * @param structureIds the structure IDs
1290            * @param start the lower bound of the range of journal articles
1291            * @param end the upper bound of the range of journal articles (not inclusive)
1292            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1293            * @return the ordered range of matching journal articles
1294            * @throws SystemException if a system exception occurred
1295            */
1296            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1297                    java.lang.String[] structureIds, int start, int end,
1298                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1299                    throws com.liferay.portal.kernel.exception.SystemException {
1300                    return getPersistence()
1301                                       .findByStructureId(structureIds, start, end,
1302                            orderByComparator);
1303            }
1304    
1305            /**
1306            * Removes all the journal articles where structureId = &#63; from the database.
1307            *
1308            * @param structureId the structure ID
1309            * @throws SystemException if a system exception occurred
1310            */
1311            public static void removeByStructureId(java.lang.String structureId)
1312                    throws com.liferay.portal.kernel.exception.SystemException {
1313                    getPersistence().removeByStructureId(structureId);
1314            }
1315    
1316            /**
1317            * Returns the number of journal articles where structureId = &#63;.
1318            *
1319            * @param structureId the structure ID
1320            * @return the number of matching journal articles
1321            * @throws SystemException if a system exception occurred
1322            */
1323            public static int countByStructureId(java.lang.String structureId)
1324                    throws com.liferay.portal.kernel.exception.SystemException {
1325                    return getPersistence().countByStructureId(structureId);
1326            }
1327    
1328            /**
1329            * Returns the number of journal articles where structureId = any &#63;.
1330            *
1331            * @param structureIds the structure IDs
1332            * @return the number of matching journal articles
1333            * @throws SystemException if a system exception occurred
1334            */
1335            public static int countByStructureId(java.lang.String[] structureIds)
1336                    throws com.liferay.portal.kernel.exception.SystemException {
1337                    return getPersistence().countByStructureId(structureIds);
1338            }
1339    
1340            /**
1341            * Returns all the journal articles where templateId = &#63;.
1342            *
1343            * @param templateId the template ID
1344            * @return the matching journal articles
1345            * @throws SystemException if a system exception occurred
1346            */
1347            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1348                    java.lang.String templateId)
1349                    throws com.liferay.portal.kernel.exception.SystemException {
1350                    return getPersistence().findByTemplateId(templateId);
1351            }
1352    
1353            /**
1354            * Returns a range of all the journal articles where templateId = &#63;.
1355            *
1356            * <p>
1357            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1358            * </p>
1359            *
1360            * @param templateId the template ID
1361            * @param start the lower bound of the range of journal articles
1362            * @param end the upper bound of the range of journal articles (not inclusive)
1363            * @return the range of matching journal articles
1364            * @throws SystemException if a system exception occurred
1365            */
1366            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1367                    java.lang.String templateId, int start, int end)
1368                    throws com.liferay.portal.kernel.exception.SystemException {
1369                    return getPersistence().findByTemplateId(templateId, start, end);
1370            }
1371    
1372            /**
1373            * Returns an ordered range of all the journal articles where templateId = &#63;.
1374            *
1375            * <p>
1376            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1377            * </p>
1378            *
1379            * @param templateId the template ID
1380            * @param start the lower bound of the range of journal articles
1381            * @param end the upper bound of the range of journal articles (not inclusive)
1382            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1383            * @return the ordered range of matching journal articles
1384            * @throws SystemException if a system exception occurred
1385            */
1386            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1387                    java.lang.String templateId, int start, int end,
1388                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1389                    throws com.liferay.portal.kernel.exception.SystemException {
1390                    return getPersistence()
1391                                       .findByTemplateId(templateId, start, end, orderByComparator);
1392            }
1393    
1394            /**
1395            * Returns the first journal article in the ordered set where templateId = &#63;.
1396            *
1397            * @param templateId the template ID
1398            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1399            * @return the first matching journal article
1400            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1401            * @throws SystemException if a system exception occurred
1402            */
1403            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1404                    java.lang.String templateId,
1405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1406                    throws com.liferay.portal.kernel.exception.SystemException,
1407                            com.liferay.portlet.journal.NoSuchArticleException {
1408                    return getPersistence()
1409                                       .findByTemplateId_First(templateId, orderByComparator);
1410            }
1411    
1412            /**
1413            * Returns the first journal article in the ordered set where templateId = &#63;.
1414            *
1415            * @param templateId the template ID
1416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1417            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1418            * @throws SystemException if a system exception occurred
1419            */
1420            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1421                    java.lang.String templateId,
1422                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1423                    throws com.liferay.portal.kernel.exception.SystemException {
1424                    return getPersistence()
1425                                       .fetchByTemplateId_First(templateId, orderByComparator);
1426            }
1427    
1428            /**
1429            * Returns the last journal article in the ordered set where templateId = &#63;.
1430            *
1431            * @param templateId the template ID
1432            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1433            * @return the last matching journal article
1434            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1435            * @throws SystemException if a system exception occurred
1436            */
1437            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1438                    java.lang.String templateId,
1439                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1440                    throws com.liferay.portal.kernel.exception.SystemException,
1441                            com.liferay.portlet.journal.NoSuchArticleException {
1442                    return getPersistence()
1443                                       .findByTemplateId_Last(templateId, orderByComparator);
1444            }
1445    
1446            /**
1447            * Returns the last journal article in the ordered set where templateId = &#63;.
1448            *
1449            * @param templateId the template ID
1450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1451            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1455                    java.lang.String templateId,
1456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1457                    throws com.liferay.portal.kernel.exception.SystemException {
1458                    return getPersistence()
1459                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1460            }
1461    
1462            /**
1463            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1464            *
1465            * @param id the primary key of the current journal article
1466            * @param templateId the template ID
1467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1468            * @return the previous, current, and next journal article
1469            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1470            * @throws SystemException if a system exception occurred
1471            */
1472            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1473                    long id, java.lang.String templateId,
1474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1475                    throws com.liferay.portal.kernel.exception.SystemException,
1476                            com.liferay.portlet.journal.NoSuchArticleException {
1477                    return getPersistence()
1478                                       .findByTemplateId_PrevAndNext(id, templateId,
1479                            orderByComparator);
1480            }
1481    
1482            /**
1483            * Removes all the journal articles where templateId = &#63; from the database.
1484            *
1485            * @param templateId the template ID
1486            * @throws SystemException if a system exception occurred
1487            */
1488            public static void removeByTemplateId(java.lang.String templateId)
1489                    throws com.liferay.portal.kernel.exception.SystemException {
1490                    getPersistence().removeByTemplateId(templateId);
1491            }
1492    
1493            /**
1494            * Returns the number of journal articles where templateId = &#63;.
1495            *
1496            * @param templateId the template ID
1497            * @return the number of matching journal articles
1498            * @throws SystemException if a system exception occurred
1499            */
1500            public static int countByTemplateId(java.lang.String templateId)
1501                    throws com.liferay.portal.kernel.exception.SystemException {
1502                    return getPersistence().countByTemplateId(templateId);
1503            }
1504    
1505            /**
1506            * Returns all the journal articles where layoutUuid = &#63;.
1507            *
1508            * @param layoutUuid the layout uuid
1509            * @return the matching journal articles
1510            * @throws SystemException if a system exception occurred
1511            */
1512            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1513                    java.lang.String layoutUuid)
1514                    throws com.liferay.portal.kernel.exception.SystemException {
1515                    return getPersistence().findByLayoutUuid(layoutUuid);
1516            }
1517    
1518            /**
1519            * Returns a range of all the journal articles where layoutUuid = &#63;.
1520            *
1521            * <p>
1522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1523            * </p>
1524            *
1525            * @param layoutUuid the layout uuid
1526            * @param start the lower bound of the range of journal articles
1527            * @param end the upper bound of the range of journal articles (not inclusive)
1528            * @return the range of matching journal articles
1529            * @throws SystemException if a system exception occurred
1530            */
1531            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1532                    java.lang.String layoutUuid, int start, int end)
1533                    throws com.liferay.portal.kernel.exception.SystemException {
1534                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1535            }
1536    
1537            /**
1538            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1539            *
1540            * <p>
1541            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1542            * </p>
1543            *
1544            * @param layoutUuid the layout uuid
1545            * @param start the lower bound of the range of journal articles
1546            * @param end the upper bound of the range of journal articles (not inclusive)
1547            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1548            * @return the ordered range of matching journal articles
1549            * @throws SystemException if a system exception occurred
1550            */
1551            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1552                    java.lang.String layoutUuid, int start, int end,
1553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence()
1556                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1557            }
1558    
1559            /**
1560            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1561            *
1562            * @param layoutUuid the layout uuid
1563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1564            * @return the first matching journal article
1565            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1566            * @throws SystemException if a system exception occurred
1567            */
1568            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First(
1569                    java.lang.String layoutUuid,
1570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1571                    throws com.liferay.portal.kernel.exception.SystemException,
1572                            com.liferay.portlet.journal.NoSuchArticleException {
1573                    return getPersistence()
1574                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1575            }
1576    
1577            /**
1578            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1579            *
1580            * @param layoutUuid the layout uuid
1581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1582            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1583            * @throws SystemException if a system exception occurred
1584            */
1585            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First(
1586                    java.lang.String layoutUuid,
1587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1588                    throws com.liferay.portal.kernel.exception.SystemException {
1589                    return getPersistence()
1590                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1591            }
1592    
1593            /**
1594            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1595            *
1596            * @param layoutUuid the layout uuid
1597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1598            * @return the last matching journal article
1599            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1600            * @throws SystemException if a system exception occurred
1601            */
1602            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last(
1603                    java.lang.String layoutUuid,
1604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1605                    throws com.liferay.portal.kernel.exception.SystemException,
1606                            com.liferay.portlet.journal.NoSuchArticleException {
1607                    return getPersistence()
1608                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1609            }
1610    
1611            /**
1612            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1613            *
1614            * @param layoutUuid the layout uuid
1615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1616            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1617            * @throws SystemException if a system exception occurred
1618            */
1619            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last(
1620                    java.lang.String layoutUuid,
1621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1622                    throws com.liferay.portal.kernel.exception.SystemException {
1623                    return getPersistence()
1624                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1625            }
1626    
1627            /**
1628            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1629            *
1630            * @param id the primary key of the current journal article
1631            * @param layoutUuid the layout uuid
1632            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1633            * @return the previous, current, and next journal article
1634            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1635            * @throws SystemException if a system exception occurred
1636            */
1637            public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext(
1638                    long id, java.lang.String layoutUuid,
1639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1640                    throws com.liferay.portal.kernel.exception.SystemException,
1641                            com.liferay.portlet.journal.NoSuchArticleException {
1642                    return getPersistence()
1643                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1644                            orderByComparator);
1645            }
1646    
1647            /**
1648            * Removes all the journal articles where layoutUuid = &#63; from the database.
1649            *
1650            * @param layoutUuid the layout uuid
1651            * @throws SystemException if a system exception occurred
1652            */
1653            public static void removeByLayoutUuid(java.lang.String layoutUuid)
1654                    throws com.liferay.portal.kernel.exception.SystemException {
1655                    getPersistence().removeByLayoutUuid(layoutUuid);
1656            }
1657    
1658            /**
1659            * Returns the number of journal articles where layoutUuid = &#63;.
1660            *
1661            * @param layoutUuid the layout uuid
1662            * @return the number of matching journal articles
1663            * @throws SystemException if a system exception occurred
1664            */
1665            public static int countByLayoutUuid(java.lang.String layoutUuid)
1666                    throws com.liferay.portal.kernel.exception.SystemException {
1667                    return getPersistence().countByLayoutUuid(layoutUuid);
1668            }
1669    
1670            /**
1671            * Returns all the journal articles where smallImageId = &#63;.
1672            *
1673            * @param smallImageId the small image ID
1674            * @return the matching journal articles
1675            * @throws SystemException if a system exception occurred
1676            */
1677            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1678                    long smallImageId)
1679                    throws com.liferay.portal.kernel.exception.SystemException {
1680                    return getPersistence().findBySmallImageId(smallImageId);
1681            }
1682    
1683            /**
1684            * Returns a range of all the journal articles where smallImageId = &#63;.
1685            *
1686            * <p>
1687            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1688            * </p>
1689            *
1690            * @param smallImageId the small image ID
1691            * @param start the lower bound of the range of journal articles
1692            * @param end the upper bound of the range of journal articles (not inclusive)
1693            * @return the range of matching journal articles
1694            * @throws SystemException if a system exception occurred
1695            */
1696            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1697                    long smallImageId, int start, int end)
1698                    throws com.liferay.portal.kernel.exception.SystemException {
1699                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1700            }
1701    
1702            /**
1703            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1704            *
1705            * <p>
1706            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1707            * </p>
1708            *
1709            * @param smallImageId the small image ID
1710            * @param start the lower bound of the range of journal articles
1711            * @param end the upper bound of the range of journal articles (not inclusive)
1712            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1713            * @return the ordered range of matching journal articles
1714            * @throws SystemException if a system exception occurred
1715            */
1716            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1717                    long smallImageId, int start, int end,
1718                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1719                    throws com.liferay.portal.kernel.exception.SystemException {
1720                    return getPersistence()
1721                                       .findBySmallImageId(smallImageId, start, end,
1722                            orderByComparator);
1723            }
1724    
1725            /**
1726            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1727            *
1728            * @param smallImageId the small image ID
1729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1730            * @return the first matching journal article
1731            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1732            * @throws SystemException if a system exception occurred
1733            */
1734            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1735                    long smallImageId,
1736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1737                    throws com.liferay.portal.kernel.exception.SystemException,
1738                            com.liferay.portlet.journal.NoSuchArticleException {
1739                    return getPersistence()
1740                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1741            }
1742    
1743            /**
1744            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1745            *
1746            * @param smallImageId the small image ID
1747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1748            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1749            * @throws SystemException if a system exception occurred
1750            */
1751            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1752                    long smallImageId,
1753                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1754                    throws com.liferay.portal.kernel.exception.SystemException {
1755                    return getPersistence()
1756                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1757            }
1758    
1759            /**
1760            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1761            *
1762            * @param smallImageId the small image ID
1763            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1764            * @return the last matching journal article
1765            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1766            * @throws SystemException if a system exception occurred
1767            */
1768            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1769                    long smallImageId,
1770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1771                    throws com.liferay.portal.kernel.exception.SystemException,
1772                            com.liferay.portlet.journal.NoSuchArticleException {
1773                    return getPersistence()
1774                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1775            }
1776    
1777            /**
1778            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1779            *
1780            * @param smallImageId the small image ID
1781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1782            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1783            * @throws SystemException if a system exception occurred
1784            */
1785            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1786                    long smallImageId,
1787                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1788                    throws com.liferay.portal.kernel.exception.SystemException {
1789                    return getPersistence()
1790                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1791            }
1792    
1793            /**
1794            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1795            *
1796            * @param id the primary key of the current journal article
1797            * @param smallImageId the small image ID
1798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1799            * @return the previous, current, and next journal article
1800            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1801            * @throws SystemException if a system exception occurred
1802            */
1803            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1804                    long id, long smallImageId,
1805                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1806                    throws com.liferay.portal.kernel.exception.SystemException,
1807                            com.liferay.portlet.journal.NoSuchArticleException {
1808                    return getPersistence()
1809                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1810                            orderByComparator);
1811            }
1812    
1813            /**
1814            * Removes all the journal articles where smallImageId = &#63; from the database.
1815            *
1816            * @param smallImageId the small image ID
1817            * @throws SystemException if a system exception occurred
1818            */
1819            public static void removeBySmallImageId(long smallImageId)
1820                    throws com.liferay.portal.kernel.exception.SystemException {
1821                    getPersistence().removeBySmallImageId(smallImageId);
1822            }
1823    
1824            /**
1825            * Returns the number of journal articles where smallImageId = &#63;.
1826            *
1827            * @param smallImageId the small image ID
1828            * @return the number of matching journal articles
1829            * @throws SystemException if a system exception occurred
1830            */
1831            public static int countBySmallImageId(long smallImageId)
1832                    throws com.liferay.portal.kernel.exception.SystemException {
1833                    return getPersistence().countBySmallImageId(smallImageId);
1834            }
1835    
1836            /**
1837            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1838            *
1839            * @param resourcePrimKey the resource prim key
1840            * @param indexable the indexable
1841            * @return the matching journal articles
1842            * @throws SystemException if a system exception occurred
1843            */
1844            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1845                    long resourcePrimKey, boolean indexable)
1846                    throws com.liferay.portal.kernel.exception.SystemException {
1847                    return getPersistence().findByR_I(resourcePrimKey, indexable);
1848            }
1849    
1850            /**
1851            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1852            *
1853            * <p>
1854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1855            * </p>
1856            *
1857            * @param resourcePrimKey the resource prim key
1858            * @param indexable the indexable
1859            * @param start the lower bound of the range of journal articles
1860            * @param end the upper bound of the range of journal articles (not inclusive)
1861            * @return the range of matching journal articles
1862            * @throws SystemException if a system exception occurred
1863            */
1864            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1865                    long resourcePrimKey, boolean indexable, int start, int end)
1866                    throws com.liferay.portal.kernel.exception.SystemException {
1867                    return getPersistence().findByR_I(resourcePrimKey, indexable, start, end);
1868            }
1869    
1870            /**
1871            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1872            *
1873            * <p>
1874            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1875            * </p>
1876            *
1877            * @param resourcePrimKey the resource prim key
1878            * @param indexable the indexable
1879            * @param start the lower bound of the range of journal articles
1880            * @param end the upper bound of the range of journal articles (not inclusive)
1881            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1882            * @return the ordered range of matching journal articles
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1886                    long resourcePrimKey, boolean indexable, int start, int end,
1887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1888                    throws com.liferay.portal.kernel.exception.SystemException {
1889                    return getPersistence()
1890                                       .findByR_I(resourcePrimKey, indexable, start, end,
1891                            orderByComparator);
1892            }
1893    
1894            /**
1895            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1896            *
1897            * @param resourcePrimKey the resource prim key
1898            * @param indexable the indexable
1899            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1900            * @return the first matching journal article
1901            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1902            * @throws SystemException if a system exception occurred
1903            */
1904            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_First(
1905                    long resourcePrimKey, boolean indexable,
1906                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1907                    throws com.liferay.portal.kernel.exception.SystemException,
1908                            com.liferay.portlet.journal.NoSuchArticleException {
1909                    return getPersistence()
1910                                       .findByR_I_First(resourcePrimKey, indexable,
1911                            orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1916            *
1917            * @param resourcePrimKey the resource prim key
1918            * @param indexable the indexable
1919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1920            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1921            * @throws SystemException if a system exception occurred
1922            */
1923            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_First(
1924                    long resourcePrimKey, boolean indexable,
1925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1926                    throws com.liferay.portal.kernel.exception.SystemException {
1927                    return getPersistence()
1928                                       .fetchByR_I_First(resourcePrimKey, indexable,
1929                            orderByComparator);
1930            }
1931    
1932            /**
1933            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1934            *
1935            * @param resourcePrimKey the resource prim key
1936            * @param indexable the indexable
1937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1938            * @return the last matching journal article
1939            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1940            * @throws SystemException if a system exception occurred
1941            */
1942            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_Last(
1943                    long resourcePrimKey, boolean indexable,
1944                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1945                    throws com.liferay.portal.kernel.exception.SystemException,
1946                            com.liferay.portlet.journal.NoSuchArticleException {
1947                    return getPersistence()
1948                                       .findByR_I_Last(resourcePrimKey, indexable, orderByComparator);
1949            }
1950    
1951            /**
1952            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1953            *
1954            * @param resourcePrimKey the resource prim key
1955            * @param indexable the indexable
1956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1957            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1958            * @throws SystemException if a system exception occurred
1959            */
1960            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_Last(
1961                    long resourcePrimKey, boolean indexable,
1962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1963                    throws com.liferay.portal.kernel.exception.SystemException {
1964                    return getPersistence()
1965                                       .fetchByR_I_Last(resourcePrimKey, indexable,
1966                            orderByComparator);
1967            }
1968    
1969            /**
1970            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1971            *
1972            * @param id the primary key of the current journal article
1973            * @param resourcePrimKey the resource prim key
1974            * @param indexable the indexable
1975            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1976            * @return the previous, current, and next journal article
1977            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1978            * @throws SystemException if a system exception occurred
1979            */
1980            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_PrevAndNext(
1981                    long id, long resourcePrimKey, boolean indexable,
1982                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1983                    throws com.liferay.portal.kernel.exception.SystemException,
1984                            com.liferay.portlet.journal.NoSuchArticleException {
1985                    return getPersistence()
1986                                       .findByR_I_PrevAndNext(id, resourcePrimKey, indexable,
1987                            orderByComparator);
1988            }
1989    
1990            /**
1991            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; from the database.
1992            *
1993            * @param resourcePrimKey the resource prim key
1994            * @param indexable the indexable
1995            * @throws SystemException if a system exception occurred
1996            */
1997            public static void removeByR_I(long resourcePrimKey, boolean indexable)
1998                    throws com.liferay.portal.kernel.exception.SystemException {
1999                    getPersistence().removeByR_I(resourcePrimKey, indexable);
2000            }
2001    
2002            /**
2003            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63;.
2004            *
2005            * @param resourcePrimKey the resource prim key
2006            * @param indexable the indexable
2007            * @return the number of matching journal articles
2008            * @throws SystemException if a system exception occurred
2009            */
2010            public static int countByR_I(long resourcePrimKey, boolean indexable)
2011                    throws com.liferay.portal.kernel.exception.SystemException {
2012                    return getPersistence().countByR_I(resourcePrimKey, indexable);
2013            }
2014    
2015            /**
2016            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2017            *
2018            * @param resourcePrimKey the resource prim key
2019            * @param status the status
2020            * @return the matching journal articles
2021            * @throws SystemException if a system exception occurred
2022            */
2023            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2024                    long resourcePrimKey, int status)
2025                    throws com.liferay.portal.kernel.exception.SystemException {
2026                    return getPersistence().findByR_ST(resourcePrimKey, status);
2027            }
2028    
2029            /**
2030            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2031            *
2032            * <p>
2033            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2034            * </p>
2035            *
2036            * @param resourcePrimKey the resource prim key
2037            * @param status the status
2038            * @param start the lower bound of the range of journal articles
2039            * @param end the upper bound of the range of journal articles (not inclusive)
2040            * @return the range of matching journal articles
2041            * @throws SystemException if a system exception occurred
2042            */
2043            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2044                    long resourcePrimKey, int status, int start, int end)
2045                    throws com.liferay.portal.kernel.exception.SystemException {
2046                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
2047            }
2048    
2049            /**
2050            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
2051            *
2052            * <p>
2053            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2054            * </p>
2055            *
2056            * @param resourcePrimKey the resource prim key
2057            * @param status the status
2058            * @param start the lower bound of the range of journal articles
2059            * @param end the upper bound of the range of journal articles (not inclusive)
2060            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2061            * @return the ordered range of matching journal articles
2062            * @throws SystemException if a system exception occurred
2063            */
2064            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2065                    long resourcePrimKey, int status, int start, int end,
2066                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2067                    throws com.liferay.portal.kernel.exception.SystemException {
2068                    return getPersistence()
2069                                       .findByR_ST(resourcePrimKey, status, start, end,
2070                            orderByComparator);
2071            }
2072    
2073            /**
2074            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2075            *
2076            * @param resourcePrimKey the resource prim key
2077            * @param status the status
2078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2079            * @return the first matching journal article
2080            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2081            * @throws SystemException if a system exception occurred
2082            */
2083            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
2084                    long resourcePrimKey, int status,
2085                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2086                    throws com.liferay.portal.kernel.exception.SystemException,
2087                            com.liferay.portlet.journal.NoSuchArticleException {
2088                    return getPersistence()
2089                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
2090            }
2091    
2092            /**
2093            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2094            *
2095            * @param resourcePrimKey the resource prim key
2096            * @param status the status
2097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2098            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2099            * @throws SystemException if a system exception occurred
2100            */
2101            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
2102                    long resourcePrimKey, int status,
2103                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2104                    throws com.liferay.portal.kernel.exception.SystemException {
2105                    return getPersistence()
2106                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
2107            }
2108    
2109            /**
2110            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2111            *
2112            * @param resourcePrimKey the resource prim key
2113            * @param status the status
2114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2115            * @return the last matching journal article
2116            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2117            * @throws SystemException if a system exception occurred
2118            */
2119            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
2120                    long resourcePrimKey, int status,
2121                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2122                    throws com.liferay.portal.kernel.exception.SystemException,
2123                            com.liferay.portlet.journal.NoSuchArticleException {
2124                    return getPersistence()
2125                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
2126            }
2127    
2128            /**
2129            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2130            *
2131            * @param resourcePrimKey the resource prim key
2132            * @param status the status
2133            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2134            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2135            * @throws SystemException if a system exception occurred
2136            */
2137            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
2138                    long resourcePrimKey, int status,
2139                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2140                    throws com.liferay.portal.kernel.exception.SystemException {
2141                    return getPersistence()
2142                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
2143            }
2144    
2145            /**
2146            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
2147            *
2148            * @param id the primary key of the current journal article
2149            * @param resourcePrimKey the resource prim key
2150            * @param status the status
2151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2152            * @return the previous, current, and next journal article
2153            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2154            * @throws SystemException if a system exception occurred
2155            */
2156            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
2157                    long id, long resourcePrimKey, int status,
2158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2159                    throws com.liferay.portal.kernel.exception.SystemException,
2160                            com.liferay.portlet.journal.NoSuchArticleException {
2161                    return getPersistence()
2162                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
2163                            orderByComparator);
2164            }
2165    
2166            /**
2167            * Returns all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
2168            *
2169            * <p>
2170            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2171            * </p>
2172            *
2173            * @param resourcePrimKey the resource prim key
2174            * @param statuses the statuses
2175            * @return the matching journal articles
2176            * @throws SystemException if a system exception occurred
2177            */
2178            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2179                    long resourcePrimKey, int[] statuses)
2180                    throws com.liferay.portal.kernel.exception.SystemException {
2181                    return getPersistence().findByR_ST(resourcePrimKey, statuses);
2182            }
2183    
2184            /**
2185            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
2186            *
2187            * <p>
2188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2189            * </p>
2190            *
2191            * @param resourcePrimKey the resource prim key
2192            * @param statuses the statuses
2193            * @param start the lower bound of the range of journal articles
2194            * @param end the upper bound of the range of journal articles (not inclusive)
2195            * @return the range of matching journal articles
2196            * @throws SystemException if a system exception occurred
2197            */
2198            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2199                    long resourcePrimKey, int[] statuses, int start, int end)
2200                    throws com.liferay.portal.kernel.exception.SystemException {
2201                    return getPersistence().findByR_ST(resourcePrimKey, statuses, start, end);
2202            }
2203    
2204            /**
2205            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
2206            *
2207            * <p>
2208            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2209            * </p>
2210            *
2211            * @param resourcePrimKey the resource prim key
2212            * @param statuses the statuses
2213            * @param start the lower bound of the range of journal articles
2214            * @param end the upper bound of the range of journal articles (not inclusive)
2215            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2216            * @return the ordered range of matching journal articles
2217            * @throws SystemException if a system exception occurred
2218            */
2219            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
2220                    long resourcePrimKey, int[] statuses, int start, int end,
2221                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2222                    throws com.liferay.portal.kernel.exception.SystemException {
2223                    return getPersistence()
2224                                       .findByR_ST(resourcePrimKey, statuses, start, end,
2225                            orderByComparator);
2226            }
2227    
2228            /**
2229            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
2230            *
2231            * @param resourcePrimKey the resource prim key
2232            * @param status the status
2233            * @throws SystemException if a system exception occurred
2234            */
2235            public static void removeByR_ST(long resourcePrimKey, int status)
2236                    throws com.liferay.portal.kernel.exception.SystemException {
2237                    getPersistence().removeByR_ST(resourcePrimKey, status);
2238            }
2239    
2240            /**
2241            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
2242            *
2243            * @param resourcePrimKey the resource prim key
2244            * @param status the status
2245            * @return the number of matching journal articles
2246            * @throws SystemException if a system exception occurred
2247            */
2248            public static int countByR_ST(long resourcePrimKey, int status)
2249                    throws com.liferay.portal.kernel.exception.SystemException {
2250                    return getPersistence().countByR_ST(resourcePrimKey, status);
2251            }
2252    
2253            /**
2254            * Returns the number of journal articles where resourcePrimKey = &#63; and status = any &#63;.
2255            *
2256            * @param resourcePrimKey the resource prim key
2257            * @param statuses the statuses
2258            * @return the number of matching journal articles
2259            * @throws SystemException if a system exception occurred
2260            */
2261            public static int countByR_ST(long resourcePrimKey, int[] statuses)
2262                    throws com.liferay.portal.kernel.exception.SystemException {
2263                    return getPersistence().countByR_ST(resourcePrimKey, statuses);
2264            }
2265    
2266            /**
2267            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
2268            *
2269            * @param groupId the group ID
2270            * @param userId the user ID
2271            * @return the matching journal articles
2272            * @throws SystemException if a system exception occurred
2273            */
2274            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2275                    long groupId, long userId)
2276                    throws com.liferay.portal.kernel.exception.SystemException {
2277                    return getPersistence().findByG_U(groupId, userId);
2278            }
2279    
2280            /**
2281            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
2282            *
2283            * <p>
2284            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2285            * </p>
2286            *
2287            * @param groupId the group ID
2288            * @param userId the user ID
2289            * @param start the lower bound of the range of journal articles
2290            * @param end the upper bound of the range of journal articles (not inclusive)
2291            * @return the range of matching journal articles
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2295                    long groupId, long userId, int start, int end)
2296                    throws com.liferay.portal.kernel.exception.SystemException {
2297                    return getPersistence().findByG_U(groupId, userId, start, end);
2298            }
2299    
2300            /**
2301            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
2302            *
2303            * <p>
2304            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2305            * </p>
2306            *
2307            * @param groupId the group ID
2308            * @param userId the user ID
2309            * @param start the lower bound of the range of journal articles
2310            * @param end the upper bound of the range of journal articles (not inclusive)
2311            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2312            * @return the ordered range of matching journal articles
2313            * @throws SystemException if a system exception occurred
2314            */
2315            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2316                    long groupId, long userId, int start, int end,
2317                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2318                    throws com.liferay.portal.kernel.exception.SystemException {
2319                    return getPersistence()
2320                                       .findByG_U(groupId, userId, start, end, orderByComparator);
2321            }
2322    
2323            /**
2324            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2325            *
2326            * @param groupId the group ID
2327            * @param userId the user ID
2328            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2329            * @return the first matching journal article
2330            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2331            * @throws SystemException if a system exception occurred
2332            */
2333            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First(
2334                    long groupId, long userId,
2335                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2336                    throws com.liferay.portal.kernel.exception.SystemException,
2337                            com.liferay.portlet.journal.NoSuchArticleException {
2338                    return getPersistence()
2339                                       .findByG_U_First(groupId, userId, orderByComparator);
2340            }
2341    
2342            /**
2343            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2344            *
2345            * @param groupId the group ID
2346            * @param userId the user ID
2347            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2348            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2349            * @throws SystemException if a system exception occurred
2350            */
2351            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First(
2352                    long groupId, long userId,
2353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2354                    throws com.liferay.portal.kernel.exception.SystemException {
2355                    return getPersistence()
2356                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2357            }
2358    
2359            /**
2360            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2361            *
2362            * @param groupId the group ID
2363            * @param userId the user ID
2364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2365            * @return the last matching journal article
2366            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2367            * @throws SystemException if a system exception occurred
2368            */
2369            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last(
2370                    long groupId, long userId,
2371                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2372                    throws com.liferay.portal.kernel.exception.SystemException,
2373                            com.liferay.portlet.journal.NoSuchArticleException {
2374                    return getPersistence()
2375                                       .findByG_U_Last(groupId, userId, orderByComparator);
2376            }
2377    
2378            /**
2379            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2380            *
2381            * @param groupId the group ID
2382            * @param userId the user ID
2383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2384            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2385            * @throws SystemException if a system exception occurred
2386            */
2387            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last(
2388                    long groupId, long userId,
2389                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2390                    throws com.liferay.portal.kernel.exception.SystemException {
2391                    return getPersistence()
2392                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2393            }
2394    
2395            /**
2396            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2397            *
2398            * @param id the primary key of the current journal article
2399            * @param groupId the group ID
2400            * @param userId the user ID
2401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2402            * @return the previous, current, and next journal article
2403            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2404            * @throws SystemException if a system exception occurred
2405            */
2406            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext(
2407                    long id, long groupId, long userId,
2408                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2409                    throws com.liferay.portal.kernel.exception.SystemException,
2410                            com.liferay.portlet.journal.NoSuchArticleException {
2411                    return getPersistence()
2412                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2413            }
2414    
2415            /**
2416            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2417            *
2418            * @param groupId the group ID
2419            * @param userId the user ID
2420            * @return the matching journal articles that the user has permission to view
2421            * @throws SystemException if a system exception occurred
2422            */
2423            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2424                    long groupId, long userId)
2425                    throws com.liferay.portal.kernel.exception.SystemException {
2426                    return getPersistence().filterFindByG_U(groupId, userId);
2427            }
2428    
2429            /**
2430            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2431            *
2432            * <p>
2433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2434            * </p>
2435            *
2436            * @param groupId the group ID
2437            * @param userId the user ID
2438            * @param start the lower bound of the range of journal articles
2439            * @param end the upper bound of the range of journal articles (not inclusive)
2440            * @return the range of matching journal articles that the user has permission to view
2441            * @throws SystemException if a system exception occurred
2442            */
2443            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2444                    long groupId, long userId, int start, int end)
2445                    throws com.liferay.portal.kernel.exception.SystemException {
2446                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2447            }
2448    
2449            /**
2450            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2451            *
2452            * <p>
2453            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2454            * </p>
2455            *
2456            * @param groupId the group ID
2457            * @param userId the user ID
2458            * @param start the lower bound of the range of journal articles
2459            * @param end the upper bound of the range of journal articles (not inclusive)
2460            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2461            * @return the ordered range of matching journal articles that the user has permission to view
2462            * @throws SystemException if a system exception occurred
2463            */
2464            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2465                    long groupId, long userId, int start, int end,
2466                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2467                    throws com.liferay.portal.kernel.exception.SystemException {
2468                    return getPersistence()
2469                                       .filterFindByG_U(groupId, userId, start, end,
2470                            orderByComparator);
2471            }
2472    
2473            /**
2474            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2475            *
2476            * @param id the primary key of the current journal article
2477            * @param groupId the group ID
2478            * @param userId the user ID
2479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2480            * @return the previous, current, and next journal article
2481            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2482            * @throws SystemException if a system exception occurred
2483            */
2484            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext(
2485                    long id, long groupId, long userId,
2486                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2487                    throws com.liferay.portal.kernel.exception.SystemException,
2488                            com.liferay.portlet.journal.NoSuchArticleException {
2489                    return getPersistence()
2490                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2491                            orderByComparator);
2492            }
2493    
2494            /**
2495            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2496            *
2497            * @param groupId the group ID
2498            * @param userId the user ID
2499            * @throws SystemException if a system exception occurred
2500            */
2501            public static void removeByG_U(long groupId, long userId)
2502                    throws com.liferay.portal.kernel.exception.SystemException {
2503                    getPersistence().removeByG_U(groupId, userId);
2504            }
2505    
2506            /**
2507            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2508            *
2509            * @param groupId the group ID
2510            * @param userId the user ID
2511            * @return the number of matching journal articles
2512            * @throws SystemException if a system exception occurred
2513            */
2514            public static int countByG_U(long groupId, long userId)
2515                    throws com.liferay.portal.kernel.exception.SystemException {
2516                    return getPersistence().countByG_U(groupId, userId);
2517            }
2518    
2519            /**
2520            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2521            *
2522            * @param groupId the group ID
2523            * @param userId the user ID
2524            * @return the number of matching journal articles that the user has permission to view
2525            * @throws SystemException if a system exception occurred
2526            */
2527            public static int filterCountByG_U(long groupId, long userId)
2528                    throws com.liferay.portal.kernel.exception.SystemException {
2529                    return getPersistence().filterCountByG_U(groupId, userId);
2530            }
2531    
2532            /**
2533            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2534            *
2535            * @param groupId the group ID
2536            * @param folderId the folder ID
2537            * @return the matching journal articles
2538            * @throws SystemException if a system exception occurred
2539            */
2540            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2541                    long groupId, long folderId)
2542                    throws com.liferay.portal.kernel.exception.SystemException {
2543                    return getPersistence().findByG_F(groupId, folderId);
2544            }
2545    
2546            /**
2547            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2548            *
2549            * <p>
2550            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2551            * </p>
2552            *
2553            * @param groupId the group ID
2554            * @param folderId the folder ID
2555            * @param start the lower bound of the range of journal articles
2556            * @param end the upper bound of the range of journal articles (not inclusive)
2557            * @return the range of matching journal articles
2558            * @throws SystemException if a system exception occurred
2559            */
2560            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2561                    long groupId, long folderId, int start, int end)
2562                    throws com.liferay.portal.kernel.exception.SystemException {
2563                    return getPersistence().findByG_F(groupId, folderId, start, end);
2564            }
2565    
2566            /**
2567            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2568            *
2569            * <p>
2570            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2571            * </p>
2572            *
2573            * @param groupId the group ID
2574            * @param folderId the folder ID
2575            * @param start the lower bound of the range of journal articles
2576            * @param end the upper bound of the range of journal articles (not inclusive)
2577            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2578            * @return the ordered range of matching journal articles
2579            * @throws SystemException if a system exception occurred
2580            */
2581            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2582                    long groupId, long folderId, int start, int end,
2583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2584                    throws com.liferay.portal.kernel.exception.SystemException {
2585                    return getPersistence()
2586                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2587            }
2588    
2589            /**
2590            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2591            *
2592            * @param groupId the group ID
2593            * @param folderId the folder ID
2594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2595            * @return the first matching journal article
2596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2597            * @throws SystemException if a system exception occurred
2598            */
2599            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First(
2600                    long groupId, long folderId,
2601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2602                    throws com.liferay.portal.kernel.exception.SystemException,
2603                            com.liferay.portlet.journal.NoSuchArticleException {
2604                    return getPersistence()
2605                                       .findByG_F_First(groupId, folderId, orderByComparator);
2606            }
2607    
2608            /**
2609            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2610            *
2611            * @param groupId the group ID
2612            * @param folderId the folder ID
2613            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2614            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2615            * @throws SystemException if a system exception occurred
2616            */
2617            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First(
2618                    long groupId, long folderId,
2619                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2620                    throws com.liferay.portal.kernel.exception.SystemException {
2621                    return getPersistence()
2622                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2623            }
2624    
2625            /**
2626            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2627            *
2628            * @param groupId the group ID
2629            * @param folderId the folder ID
2630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2631            * @return the last matching journal article
2632            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2633            * @throws SystemException if a system exception occurred
2634            */
2635            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last(
2636                    long groupId, long folderId,
2637                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2638                    throws com.liferay.portal.kernel.exception.SystemException,
2639                            com.liferay.portlet.journal.NoSuchArticleException {
2640                    return getPersistence()
2641                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2642            }
2643    
2644            /**
2645            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2646            *
2647            * @param groupId the group ID
2648            * @param folderId the folder ID
2649            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2650            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2651            * @throws SystemException if a system exception occurred
2652            */
2653            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last(
2654                    long groupId, long folderId,
2655                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2656                    throws com.liferay.portal.kernel.exception.SystemException {
2657                    return getPersistence()
2658                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2659            }
2660    
2661            /**
2662            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2663            *
2664            * @param id the primary key of the current journal article
2665            * @param groupId the group ID
2666            * @param folderId the folder ID
2667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2668            * @return the previous, current, and next journal article
2669            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2670            * @throws SystemException if a system exception occurred
2671            */
2672            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext(
2673                    long id, long groupId, long folderId,
2674                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2675                    throws com.liferay.portal.kernel.exception.SystemException,
2676                            com.liferay.portlet.journal.NoSuchArticleException {
2677                    return getPersistence()
2678                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2679                            orderByComparator);
2680            }
2681    
2682            /**
2683            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2684            *
2685            * @param groupId the group ID
2686            * @param folderId the folder ID
2687            * @return the matching journal articles that the user has permission to view
2688            * @throws SystemException if a system exception occurred
2689            */
2690            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2691                    long groupId, long folderId)
2692                    throws com.liferay.portal.kernel.exception.SystemException {
2693                    return getPersistence().filterFindByG_F(groupId, folderId);
2694            }
2695    
2696            /**
2697            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2698            *
2699            * <p>
2700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2701            * </p>
2702            *
2703            * @param groupId the group ID
2704            * @param folderId the folder ID
2705            * @param start the lower bound of the range of journal articles
2706            * @param end the upper bound of the range of journal articles (not inclusive)
2707            * @return the range of matching journal articles that the user has permission to view
2708            * @throws SystemException if a system exception occurred
2709            */
2710            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2711                    long groupId, long folderId, int start, int end)
2712                    throws com.liferay.portal.kernel.exception.SystemException {
2713                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2714            }
2715    
2716            /**
2717            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2718            *
2719            * <p>
2720            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2721            * </p>
2722            *
2723            * @param groupId the group ID
2724            * @param folderId the folder ID
2725            * @param start the lower bound of the range of journal articles
2726            * @param end the upper bound of the range of journal articles (not inclusive)
2727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2728            * @return the ordered range of matching journal articles that the user has permission to view
2729            * @throws SystemException if a system exception occurred
2730            */
2731            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2732                    long groupId, long folderId, int start, int end,
2733                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2734                    throws com.liferay.portal.kernel.exception.SystemException {
2735                    return getPersistence()
2736                                       .filterFindByG_F(groupId, folderId, start, end,
2737                            orderByComparator);
2738            }
2739    
2740            /**
2741            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2742            *
2743            * @param id the primary key of the current journal article
2744            * @param groupId the group ID
2745            * @param folderId the folder ID
2746            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2747            * @return the previous, current, and next journal article
2748            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2749            * @throws SystemException if a system exception occurred
2750            */
2751            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext(
2752                    long id, long groupId, long folderId,
2753                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2754                    throws com.liferay.portal.kernel.exception.SystemException,
2755                            com.liferay.portlet.journal.NoSuchArticleException {
2756                    return getPersistence()
2757                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2758                            orderByComparator);
2759            }
2760    
2761            /**
2762            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2763            *
2764            * @param groupId the group ID
2765            * @param folderIds the folder IDs
2766            * @return the matching journal articles that the user has permission to view
2767            * @throws SystemException if a system exception occurred
2768            */
2769            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2770                    long groupId, long[] folderIds)
2771                    throws com.liferay.portal.kernel.exception.SystemException {
2772                    return getPersistence().filterFindByG_F(groupId, folderIds);
2773            }
2774    
2775            /**
2776            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2777            *
2778            * <p>
2779            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2780            * </p>
2781            *
2782            * @param groupId the group ID
2783            * @param folderIds the folder IDs
2784            * @param start the lower bound of the range of journal articles
2785            * @param end the upper bound of the range of journal articles (not inclusive)
2786            * @return the range of matching journal articles that the user has permission to view
2787            * @throws SystemException if a system exception occurred
2788            */
2789            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2790                    long groupId, long[] folderIds, int start, int end)
2791                    throws com.liferay.portal.kernel.exception.SystemException {
2792                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2793            }
2794    
2795            /**
2796            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2797            *
2798            * <p>
2799            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2800            * </p>
2801            *
2802            * @param groupId the group ID
2803            * @param folderIds the folder IDs
2804            * @param start the lower bound of the range of journal articles
2805            * @param end the upper bound of the range of journal articles (not inclusive)
2806            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2807            * @return the ordered range of matching journal articles that the user has permission to view
2808            * @throws SystemException if a system exception occurred
2809            */
2810            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2811                    long groupId, long[] folderIds, int start, int end,
2812                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2813                    throws com.liferay.portal.kernel.exception.SystemException {
2814                    return getPersistence()
2815                                       .filterFindByG_F(groupId, folderIds, start, end,
2816                            orderByComparator);
2817            }
2818    
2819            /**
2820            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2821            *
2822            * <p>
2823            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2824            * </p>
2825            *
2826            * @param groupId the group ID
2827            * @param folderIds the folder IDs
2828            * @return the matching journal articles
2829            * @throws SystemException if a system exception occurred
2830            */
2831            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2832                    long groupId, long[] folderIds)
2833                    throws com.liferay.portal.kernel.exception.SystemException {
2834                    return getPersistence().findByG_F(groupId, folderIds);
2835            }
2836    
2837            /**
2838            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2839            *
2840            * <p>
2841            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2842            * </p>
2843            *
2844            * @param groupId the group ID
2845            * @param folderIds the folder IDs
2846            * @param start the lower bound of the range of journal articles
2847            * @param end the upper bound of the range of journal articles (not inclusive)
2848            * @return the range of matching journal articles
2849            * @throws SystemException if a system exception occurred
2850            */
2851            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2852                    long groupId, long[] folderIds, int start, int end)
2853                    throws com.liferay.portal.kernel.exception.SystemException {
2854                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2855            }
2856    
2857            /**
2858            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2859            *
2860            * <p>
2861            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2862            * </p>
2863            *
2864            * @param groupId the group ID
2865            * @param folderIds the folder IDs
2866            * @param start the lower bound of the range of journal articles
2867            * @param end the upper bound of the range of journal articles (not inclusive)
2868            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2869            * @return the ordered range of matching journal articles
2870            * @throws SystemException if a system exception occurred
2871            */
2872            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2873                    long groupId, long[] folderIds, int start, int end,
2874                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2875                    throws com.liferay.portal.kernel.exception.SystemException {
2876                    return getPersistence()
2877                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2878            }
2879    
2880            /**
2881            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2882            *
2883            * @param groupId the group ID
2884            * @param folderId the folder ID
2885            * @throws SystemException if a system exception occurred
2886            */
2887            public static void removeByG_F(long groupId, long folderId)
2888                    throws com.liferay.portal.kernel.exception.SystemException {
2889                    getPersistence().removeByG_F(groupId, folderId);
2890            }
2891    
2892            /**
2893            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2894            *
2895            * @param groupId the group ID
2896            * @param folderId the folder ID
2897            * @return the number of matching journal articles
2898            * @throws SystemException if a system exception occurred
2899            */
2900            public static int countByG_F(long groupId, long folderId)
2901                    throws com.liferay.portal.kernel.exception.SystemException {
2902                    return getPersistence().countByG_F(groupId, folderId);
2903            }
2904    
2905            /**
2906            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2907            *
2908            * @param groupId the group ID
2909            * @param folderIds the folder IDs
2910            * @return the number of matching journal articles
2911            * @throws SystemException if a system exception occurred
2912            */
2913            public static int countByG_F(long groupId, long[] folderIds)
2914                    throws com.liferay.portal.kernel.exception.SystemException {
2915                    return getPersistence().countByG_F(groupId, folderIds);
2916            }
2917    
2918            /**
2919            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2920            *
2921            * @param groupId the group ID
2922            * @param folderId the folder ID
2923            * @return the number of matching journal articles that the user has permission to view
2924            * @throws SystemException if a system exception occurred
2925            */
2926            public static int filterCountByG_F(long groupId, long folderId)
2927                    throws com.liferay.portal.kernel.exception.SystemException {
2928                    return getPersistence().filterCountByG_F(groupId, folderId);
2929            }
2930    
2931            /**
2932            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2933            *
2934            * @param groupId the group ID
2935            * @param folderIds the folder IDs
2936            * @return the number of matching journal articles that the user has permission to view
2937            * @throws SystemException if a system exception occurred
2938            */
2939            public static int filterCountByG_F(long groupId, long[] folderIds)
2940                    throws com.liferay.portal.kernel.exception.SystemException {
2941                    return getPersistence().filterCountByG_F(groupId, folderIds);
2942            }
2943    
2944            /**
2945            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2946            *
2947            * @param groupId the group ID
2948            * @param articleId the article ID
2949            * @return the matching journal articles
2950            * @throws SystemException if a system exception occurred
2951            */
2952            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2953                    long groupId, java.lang.String articleId)
2954                    throws com.liferay.portal.kernel.exception.SystemException {
2955                    return getPersistence().findByG_A(groupId, articleId);
2956            }
2957    
2958            /**
2959            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2960            *
2961            * <p>
2962            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2963            * </p>
2964            *
2965            * @param groupId the group ID
2966            * @param articleId the article ID
2967            * @param start the lower bound of the range of journal articles
2968            * @param end the upper bound of the range of journal articles (not inclusive)
2969            * @return the range of matching journal articles
2970            * @throws SystemException if a system exception occurred
2971            */
2972            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2973                    long groupId, java.lang.String articleId, int start, int end)
2974                    throws com.liferay.portal.kernel.exception.SystemException {
2975                    return getPersistence().findByG_A(groupId, articleId, start, end);
2976            }
2977    
2978            /**
2979            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2980            *
2981            * <p>
2982            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2983            * </p>
2984            *
2985            * @param groupId the group ID
2986            * @param articleId the article ID
2987            * @param start the lower bound of the range of journal articles
2988            * @param end the upper bound of the range of journal articles (not inclusive)
2989            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2990            * @return the ordered range of matching journal articles
2991            * @throws SystemException if a system exception occurred
2992            */
2993            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2994                    long groupId, java.lang.String articleId, int start, int end,
2995                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2996                    throws com.liferay.portal.kernel.exception.SystemException {
2997                    return getPersistence()
2998                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2999            }
3000    
3001            /**
3002            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3003            *
3004            * @param groupId the group ID
3005            * @param articleId the article ID
3006            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3007            * @return the first matching journal article
3008            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3009            * @throws SystemException if a system exception occurred
3010            */
3011            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
3012                    long groupId, java.lang.String articleId,
3013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3014                    throws com.liferay.portal.kernel.exception.SystemException,
3015                            com.liferay.portlet.journal.NoSuchArticleException {
3016                    return getPersistence()
3017                                       .findByG_A_First(groupId, articleId, orderByComparator);
3018            }
3019    
3020            /**
3021            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3022            *
3023            * @param groupId the group ID
3024            * @param articleId the article ID
3025            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3026            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3027            * @throws SystemException if a system exception occurred
3028            */
3029            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First(
3030                    long groupId, java.lang.String articleId,
3031                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3032                    throws com.liferay.portal.kernel.exception.SystemException {
3033                    return getPersistence()
3034                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
3035            }
3036    
3037            /**
3038            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3039            *
3040            * @param groupId the group ID
3041            * @param articleId the article ID
3042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3043            * @return the last matching journal article
3044            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3045            * @throws SystemException if a system exception occurred
3046            */
3047            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
3048                    long groupId, java.lang.String articleId,
3049                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3050                    throws com.liferay.portal.kernel.exception.SystemException,
3051                            com.liferay.portlet.journal.NoSuchArticleException {
3052                    return getPersistence()
3053                                       .findByG_A_Last(groupId, articleId, orderByComparator);
3054            }
3055    
3056            /**
3057            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3058            *
3059            * @param groupId the group ID
3060            * @param articleId the article ID
3061            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3062            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3063            * @throws SystemException if a system exception occurred
3064            */
3065            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
3066                    long groupId, java.lang.String articleId,
3067                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3068                    throws com.liferay.portal.kernel.exception.SystemException {
3069                    return getPersistence()
3070                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
3071            }
3072    
3073            /**
3074            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
3075            *
3076            * @param id the primary key of the current journal article
3077            * @param groupId the group ID
3078            * @param articleId the article ID
3079            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3080            * @return the previous, current, and next journal article
3081            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3082            * @throws SystemException if a system exception occurred
3083            */
3084            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
3085                    long id, long groupId, java.lang.String articleId,
3086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3087                    throws com.liferay.portal.kernel.exception.SystemException,
3088                            com.liferay.portlet.journal.NoSuchArticleException {
3089                    return getPersistence()
3090                                       .findByG_A_PrevAndNext(id, groupId, articleId,
3091                            orderByComparator);
3092            }
3093    
3094            /**
3095            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3096            *
3097            * @param groupId the group ID
3098            * @param articleId the article ID
3099            * @return the matching journal articles that the user has permission to view
3100            * @throws SystemException if a system exception occurred
3101            */
3102            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
3103                    long groupId, java.lang.String articleId)
3104                    throws com.liferay.portal.kernel.exception.SystemException {
3105                    return getPersistence().filterFindByG_A(groupId, articleId);
3106            }
3107    
3108            /**
3109            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3110            *
3111            * <p>
3112            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3113            * </p>
3114            *
3115            * @param groupId the group ID
3116            * @param articleId the article ID
3117            * @param start the lower bound of the range of journal articles
3118            * @param end the upper bound of the range of journal articles (not inclusive)
3119            * @return the range of matching journal articles that the user has permission to view
3120            * @throws SystemException if a system exception occurred
3121            */
3122            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
3123                    long groupId, java.lang.String articleId, int start, int end)
3124                    throws com.liferay.portal.kernel.exception.SystemException {
3125                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
3126            }
3127    
3128            /**
3129            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
3130            *
3131            * <p>
3132            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3133            * </p>
3134            *
3135            * @param groupId the group ID
3136            * @param articleId the article ID
3137            * @param start the lower bound of the range of journal articles
3138            * @param end the upper bound of the range of journal articles (not inclusive)
3139            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3140            * @return the ordered range of matching journal articles that the user has permission to view
3141            * @throws SystemException if a system exception occurred
3142            */
3143            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
3144                    long groupId, java.lang.String articleId, int start, int end,
3145                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3146                    throws com.liferay.portal.kernel.exception.SystemException {
3147                    return getPersistence()
3148                                       .filterFindByG_A(groupId, articleId, start, end,
3149                            orderByComparator);
3150            }
3151    
3152            /**
3153            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3154            *
3155            * @param id the primary key of the current journal article
3156            * @param groupId the group ID
3157            * @param articleId the article ID
3158            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3159            * @return the previous, current, and next journal article
3160            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3161            * @throws SystemException if a system exception occurred
3162            */
3163            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
3164                    long id, long groupId, java.lang.String articleId,
3165                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3166                    throws com.liferay.portal.kernel.exception.SystemException,
3167                            com.liferay.portlet.journal.NoSuchArticleException {
3168                    return getPersistence()
3169                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
3170                            orderByComparator);
3171            }
3172    
3173            /**
3174            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
3175            *
3176            * @param groupId the group ID
3177            * @param articleId the article ID
3178            * @throws SystemException if a system exception occurred
3179            */
3180            public static void removeByG_A(long groupId, java.lang.String articleId)
3181                    throws com.liferay.portal.kernel.exception.SystemException {
3182                    getPersistence().removeByG_A(groupId, articleId);
3183            }
3184    
3185            /**
3186            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
3187            *
3188            * @param groupId the group ID
3189            * @param articleId the article ID
3190            * @return the number of matching journal articles
3191            * @throws SystemException if a system exception occurred
3192            */
3193            public static int countByG_A(long groupId, java.lang.String articleId)
3194                    throws com.liferay.portal.kernel.exception.SystemException {
3195                    return getPersistence().countByG_A(groupId, articleId);
3196            }
3197    
3198            /**
3199            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
3200            *
3201            * @param groupId the group ID
3202            * @param articleId the article ID
3203            * @return the number of matching journal articles that the user has permission to view
3204            * @throws SystemException if a system exception occurred
3205            */
3206            public static int filterCountByG_A(long groupId, java.lang.String articleId)
3207                    throws com.liferay.portal.kernel.exception.SystemException {
3208                    return getPersistence().filterCountByG_A(groupId, articleId);
3209            }
3210    
3211            /**
3212            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
3213            *
3214            * @param groupId the group ID
3215            * @param urlTitle the url title
3216            * @return the matching journal articles
3217            * @throws SystemException if a system exception occurred
3218            */
3219            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3220                    long groupId, java.lang.String urlTitle)
3221                    throws com.liferay.portal.kernel.exception.SystemException {
3222                    return getPersistence().findByG_UT(groupId, urlTitle);
3223            }
3224    
3225            /**
3226            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
3227            *
3228            * <p>
3229            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3230            * </p>
3231            *
3232            * @param groupId the group ID
3233            * @param urlTitle the url title
3234            * @param start the lower bound of the range of journal articles
3235            * @param end the upper bound of the range of journal articles (not inclusive)
3236            * @return the range of matching journal articles
3237            * @throws SystemException if a system exception occurred
3238            */
3239            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3240                    long groupId, java.lang.String urlTitle, int start, int end)
3241                    throws com.liferay.portal.kernel.exception.SystemException {
3242                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
3243            }
3244    
3245            /**
3246            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
3247            *
3248            * <p>
3249            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3250            * </p>
3251            *
3252            * @param groupId the group ID
3253            * @param urlTitle the url title
3254            * @param start the lower bound of the range of journal articles
3255            * @param end the upper bound of the range of journal articles (not inclusive)
3256            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3257            * @return the ordered range of matching journal articles
3258            * @throws SystemException if a system exception occurred
3259            */
3260            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3261                    long groupId, java.lang.String urlTitle, int start, int end,
3262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3263                    throws com.liferay.portal.kernel.exception.SystemException {
3264                    return getPersistence()
3265                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
3266            }
3267    
3268            /**
3269            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3270            *
3271            * @param groupId the group ID
3272            * @param urlTitle the url title
3273            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3274            * @return the first matching journal article
3275            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3276            * @throws SystemException if a system exception occurred
3277            */
3278            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
3279                    long groupId, java.lang.String urlTitle,
3280                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3281                    throws com.liferay.portal.kernel.exception.SystemException,
3282                            com.liferay.portlet.journal.NoSuchArticleException {
3283                    return getPersistence()
3284                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
3285            }
3286    
3287            /**
3288            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3289            *
3290            * @param groupId the group ID
3291            * @param urlTitle the url title
3292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3293            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3294            * @throws SystemException if a system exception occurred
3295            */
3296            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
3297                    long groupId, java.lang.String urlTitle,
3298                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3299                    throws com.liferay.portal.kernel.exception.SystemException {
3300                    return getPersistence()
3301                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
3302            }
3303    
3304            /**
3305            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3306            *
3307            * @param groupId the group ID
3308            * @param urlTitle the url title
3309            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3310            * @return the last matching journal article
3311            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3312            * @throws SystemException if a system exception occurred
3313            */
3314            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
3315                    long groupId, java.lang.String urlTitle,
3316                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3317                    throws com.liferay.portal.kernel.exception.SystemException,
3318                            com.liferay.portlet.journal.NoSuchArticleException {
3319                    return getPersistence()
3320                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
3321            }
3322    
3323            /**
3324            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3325            *
3326            * @param groupId the group ID
3327            * @param urlTitle the url title
3328            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3329            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3330            * @throws SystemException if a system exception occurred
3331            */
3332            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
3333                    long groupId, java.lang.String urlTitle,
3334                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3335                    throws com.liferay.portal.kernel.exception.SystemException {
3336                    return getPersistence()
3337                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
3338            }
3339    
3340            /**
3341            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3342            *
3343            * @param id the primary key of the current journal article
3344            * @param groupId the group ID
3345            * @param urlTitle the url title
3346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3347            * @return the previous, current, and next journal article
3348            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3349            * @throws SystemException if a system exception occurred
3350            */
3351            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
3352                    long id, long groupId, java.lang.String urlTitle,
3353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3354                    throws com.liferay.portal.kernel.exception.SystemException,
3355                            com.liferay.portlet.journal.NoSuchArticleException {
3356                    return getPersistence()
3357                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
3358                            orderByComparator);
3359            }
3360    
3361            /**
3362            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3363            *
3364            * @param groupId the group ID
3365            * @param urlTitle the url title
3366            * @return the matching journal articles that the user has permission to view
3367            * @throws SystemException if a system exception occurred
3368            */
3369            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3370                    long groupId, java.lang.String urlTitle)
3371                    throws com.liferay.portal.kernel.exception.SystemException {
3372                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
3373            }
3374    
3375            /**
3376            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3377            *
3378            * <p>
3379            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3380            * </p>
3381            *
3382            * @param groupId the group ID
3383            * @param urlTitle the url title
3384            * @param start the lower bound of the range of journal articles
3385            * @param end the upper bound of the range of journal articles (not inclusive)
3386            * @return the range of matching journal articles that the user has permission to view
3387            * @throws SystemException if a system exception occurred
3388            */
3389            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3390                    long groupId, java.lang.String urlTitle, int start, int end)
3391                    throws com.liferay.portal.kernel.exception.SystemException {
3392                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
3393            }
3394    
3395            /**
3396            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
3397            *
3398            * <p>
3399            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3400            * </p>
3401            *
3402            * @param groupId the group ID
3403            * @param urlTitle the url title
3404            * @param start the lower bound of the range of journal articles
3405            * @param end the upper bound of the range of journal articles (not inclusive)
3406            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3407            * @return the ordered range of matching journal articles that the user has permission to view
3408            * @throws SystemException if a system exception occurred
3409            */
3410            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3411                    long groupId, java.lang.String urlTitle, int start, int end,
3412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3413                    throws com.liferay.portal.kernel.exception.SystemException {
3414                    return getPersistence()
3415                                       .filterFindByG_UT(groupId, urlTitle, start, end,
3416                            orderByComparator);
3417            }
3418    
3419            /**
3420            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3421            *
3422            * @param id the primary key of the current journal article
3423            * @param groupId the group ID
3424            * @param urlTitle the url title
3425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3426            * @return the previous, current, and next journal article
3427            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3428            * @throws SystemException if a system exception occurred
3429            */
3430            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
3431                    long id, long groupId, java.lang.String urlTitle,
3432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3433                    throws com.liferay.portal.kernel.exception.SystemException,
3434                            com.liferay.portlet.journal.NoSuchArticleException {
3435                    return getPersistence()
3436                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
3437                            orderByComparator);
3438            }
3439    
3440            /**
3441            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3442            *
3443            * @param groupId the group ID
3444            * @param urlTitle the url title
3445            * @throws SystemException if a system exception occurred
3446            */
3447            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
3448                    throws com.liferay.portal.kernel.exception.SystemException {
3449                    getPersistence().removeByG_UT(groupId, urlTitle);
3450            }
3451    
3452            /**
3453            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3454            *
3455            * @param groupId the group ID
3456            * @param urlTitle the url title
3457            * @return the number of matching journal articles
3458            * @throws SystemException if a system exception occurred
3459            */
3460            public static int countByG_UT(long groupId, java.lang.String urlTitle)
3461                    throws com.liferay.portal.kernel.exception.SystemException {
3462                    return getPersistence().countByG_UT(groupId, urlTitle);
3463            }
3464    
3465            /**
3466            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3467            *
3468            * @param groupId the group ID
3469            * @param urlTitle the url title
3470            * @return the number of matching journal articles that the user has permission to view
3471            * @throws SystemException if a system exception occurred
3472            */
3473            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
3474                    throws com.liferay.portal.kernel.exception.SystemException {
3475                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3476            }
3477    
3478            /**
3479            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
3480            *
3481            * @param groupId the group ID
3482            * @param structureId the structure ID
3483            * @return the matching journal articles
3484            * @throws SystemException if a system exception occurred
3485            */
3486            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3487                    long groupId, java.lang.String structureId)
3488                    throws com.liferay.portal.kernel.exception.SystemException {
3489                    return getPersistence().findByG_S(groupId, structureId);
3490            }
3491    
3492            /**
3493            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
3494            *
3495            * <p>
3496            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3497            * </p>
3498            *
3499            * @param groupId the group ID
3500            * @param structureId the structure ID
3501            * @param start the lower bound of the range of journal articles
3502            * @param end the upper bound of the range of journal articles (not inclusive)
3503            * @return the range of matching journal articles
3504            * @throws SystemException if a system exception occurred
3505            */
3506            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3507                    long groupId, java.lang.String structureId, int start, int end)
3508                    throws com.liferay.portal.kernel.exception.SystemException {
3509                    return getPersistence().findByG_S(groupId, structureId, start, end);
3510            }
3511    
3512            /**
3513            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
3514            *
3515            * <p>
3516            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3517            * </p>
3518            *
3519            * @param groupId the group ID
3520            * @param structureId the structure ID
3521            * @param start the lower bound of the range of journal articles
3522            * @param end the upper bound of the range of journal articles (not inclusive)
3523            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3524            * @return the ordered range of matching journal articles
3525            * @throws SystemException if a system exception occurred
3526            */
3527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3528                    long groupId, java.lang.String structureId, int start, int end,
3529                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3530                    throws com.liferay.portal.kernel.exception.SystemException {
3531                    return getPersistence()
3532                                       .findByG_S(groupId, structureId, start, end,
3533                            orderByComparator);
3534            }
3535    
3536            /**
3537            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3538            *
3539            * @param groupId the group ID
3540            * @param structureId the structure ID
3541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3542            * @return the first matching journal article
3543            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3544            * @throws SystemException if a system exception occurred
3545            */
3546            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
3547                    long groupId, java.lang.String structureId,
3548                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3549                    throws com.liferay.portal.kernel.exception.SystemException,
3550                            com.liferay.portlet.journal.NoSuchArticleException {
3551                    return getPersistence()
3552                                       .findByG_S_First(groupId, structureId, orderByComparator);
3553            }
3554    
3555            /**
3556            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3557            *
3558            * @param groupId the group ID
3559            * @param structureId the structure ID
3560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3561            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3562            * @throws SystemException if a system exception occurred
3563            */
3564            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
3565                    long groupId, java.lang.String structureId,
3566                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3567                    throws com.liferay.portal.kernel.exception.SystemException {
3568                    return getPersistence()
3569                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
3570            }
3571    
3572            /**
3573            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3574            *
3575            * @param groupId the group ID
3576            * @param structureId the structure ID
3577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3578            * @return the last matching journal article
3579            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3580            * @throws SystemException if a system exception occurred
3581            */
3582            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
3583                    long groupId, java.lang.String structureId,
3584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3585                    throws com.liferay.portal.kernel.exception.SystemException,
3586                            com.liferay.portlet.journal.NoSuchArticleException {
3587                    return getPersistence()
3588                                       .findByG_S_Last(groupId, structureId, orderByComparator);
3589            }
3590    
3591            /**
3592            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3593            *
3594            * @param groupId the group ID
3595            * @param structureId the structure ID
3596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3597            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3598            * @throws SystemException if a system exception occurred
3599            */
3600            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
3601                    long groupId, java.lang.String structureId,
3602                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3603                    throws com.liferay.portal.kernel.exception.SystemException {
3604                    return getPersistence()
3605                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
3606            }
3607    
3608            /**
3609            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3610            *
3611            * @param id the primary key of the current journal article
3612            * @param groupId the group ID
3613            * @param structureId the structure ID
3614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3615            * @return the previous, current, and next journal article
3616            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3617            * @throws SystemException if a system exception occurred
3618            */
3619            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
3620                    long id, long groupId, java.lang.String structureId,
3621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3622                    throws com.liferay.portal.kernel.exception.SystemException,
3623                            com.liferay.portlet.journal.NoSuchArticleException {
3624                    return getPersistence()
3625                                       .findByG_S_PrevAndNext(id, groupId, structureId,
3626                            orderByComparator);
3627            }
3628    
3629            /**
3630            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3631            *
3632            * @param groupId the group ID
3633            * @param structureId the structure ID
3634            * @return the matching journal articles that the user has permission to view
3635            * @throws SystemException if a system exception occurred
3636            */
3637            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3638                    long groupId, java.lang.String structureId)
3639                    throws com.liferay.portal.kernel.exception.SystemException {
3640                    return getPersistence().filterFindByG_S(groupId, structureId);
3641            }
3642    
3643            /**
3644            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3645            *
3646            * <p>
3647            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3648            * </p>
3649            *
3650            * @param groupId the group ID
3651            * @param structureId the structure ID
3652            * @param start the lower bound of the range of journal articles
3653            * @param end the upper bound of the range of journal articles (not inclusive)
3654            * @return the range of matching journal articles that the user has permission to view
3655            * @throws SystemException if a system exception occurred
3656            */
3657            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3658                    long groupId, java.lang.String structureId, int start, int end)
3659                    throws com.liferay.portal.kernel.exception.SystemException {
3660                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
3661            }
3662    
3663            /**
3664            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
3665            *
3666            * <p>
3667            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3668            * </p>
3669            *
3670            * @param groupId the group ID
3671            * @param structureId the structure ID
3672            * @param start the lower bound of the range of journal articles
3673            * @param end the upper bound of the range of journal articles (not inclusive)
3674            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3675            * @return the ordered range of matching journal articles that the user has permission to view
3676            * @throws SystemException if a system exception occurred
3677            */
3678            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3679                    long groupId, java.lang.String structureId, int start, int end,
3680                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3681                    throws com.liferay.portal.kernel.exception.SystemException {
3682                    return getPersistence()
3683                                       .filterFindByG_S(groupId, structureId, start, end,
3684                            orderByComparator);
3685            }
3686    
3687            /**
3688            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3689            *
3690            * @param id the primary key of the current journal article
3691            * @param groupId the group ID
3692            * @param structureId the structure ID
3693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3694            * @return the previous, current, and next journal article
3695            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3696            * @throws SystemException if a system exception occurred
3697            */
3698            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
3699                    long id, long groupId, java.lang.String structureId,
3700                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3701                    throws com.liferay.portal.kernel.exception.SystemException,
3702                            com.liferay.portlet.journal.NoSuchArticleException {
3703                    return getPersistence()
3704                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
3705                            orderByComparator);
3706            }
3707    
3708            /**
3709            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
3710            *
3711            * @param groupId the group ID
3712            * @param structureId the structure ID
3713            * @throws SystemException if a system exception occurred
3714            */
3715            public static void removeByG_S(long groupId, java.lang.String structureId)
3716                    throws com.liferay.portal.kernel.exception.SystemException {
3717                    getPersistence().removeByG_S(groupId, structureId);
3718            }
3719    
3720            /**
3721            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
3722            *
3723            * @param groupId the group ID
3724            * @param structureId the structure ID
3725            * @return the number of matching journal articles
3726            * @throws SystemException if a system exception occurred
3727            */
3728            public static int countByG_S(long groupId, java.lang.String structureId)
3729                    throws com.liferay.portal.kernel.exception.SystemException {
3730                    return getPersistence().countByG_S(groupId, structureId);
3731            }
3732    
3733            /**
3734            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3735            *
3736            * @param groupId the group ID
3737            * @param structureId the structure ID
3738            * @return the number of matching journal articles that the user has permission to view
3739            * @throws SystemException if a system exception occurred
3740            */
3741            public static int filterCountByG_S(long groupId,
3742                    java.lang.String structureId)
3743                    throws com.liferay.portal.kernel.exception.SystemException {
3744                    return getPersistence().filterCountByG_S(groupId, structureId);
3745            }
3746    
3747            /**
3748            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
3749            *
3750            * @param groupId the group ID
3751            * @param templateId the template ID
3752            * @return the matching journal articles
3753            * @throws SystemException if a system exception occurred
3754            */
3755            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3756                    long groupId, java.lang.String templateId)
3757                    throws com.liferay.portal.kernel.exception.SystemException {
3758                    return getPersistence().findByG_T(groupId, templateId);
3759            }
3760    
3761            /**
3762            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
3763            *
3764            * <p>
3765            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3766            * </p>
3767            *
3768            * @param groupId the group ID
3769            * @param templateId the template ID
3770            * @param start the lower bound of the range of journal articles
3771            * @param end the upper bound of the range of journal articles (not inclusive)
3772            * @return the range of matching journal articles
3773            * @throws SystemException if a system exception occurred
3774            */
3775            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3776                    long groupId, java.lang.String templateId, int start, int end)
3777                    throws com.liferay.portal.kernel.exception.SystemException {
3778                    return getPersistence().findByG_T(groupId, templateId, start, end);
3779            }
3780    
3781            /**
3782            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
3783            *
3784            * <p>
3785            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3786            * </p>
3787            *
3788            * @param groupId the group ID
3789            * @param templateId the template ID
3790            * @param start the lower bound of the range of journal articles
3791            * @param end the upper bound of the range of journal articles (not inclusive)
3792            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3793            * @return the ordered range of matching journal articles
3794            * @throws SystemException if a system exception occurred
3795            */
3796            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3797                    long groupId, java.lang.String templateId, int start, int end,
3798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3799                    throws com.liferay.portal.kernel.exception.SystemException {
3800                    return getPersistence()
3801                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
3802            }
3803    
3804            /**
3805            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3806            *
3807            * @param groupId the group ID
3808            * @param templateId the template ID
3809            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3810            * @return the first matching journal article
3811            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3812            * @throws SystemException if a system exception occurred
3813            */
3814            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
3815                    long groupId, java.lang.String templateId,
3816                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3817                    throws com.liferay.portal.kernel.exception.SystemException,
3818                            com.liferay.portlet.journal.NoSuchArticleException {
3819                    return getPersistence()
3820                                       .findByG_T_First(groupId, templateId, orderByComparator);
3821            }
3822    
3823            /**
3824            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3825            *
3826            * @param groupId the group ID
3827            * @param templateId the template ID
3828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3829            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3830            * @throws SystemException if a system exception occurred
3831            */
3832            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
3833                    long groupId, java.lang.String templateId,
3834                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3835                    throws com.liferay.portal.kernel.exception.SystemException {
3836                    return getPersistence()
3837                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
3838            }
3839    
3840            /**
3841            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3842            *
3843            * @param groupId the group ID
3844            * @param templateId the template ID
3845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3846            * @return the last matching journal article
3847            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3848            * @throws SystemException if a system exception occurred
3849            */
3850            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
3851                    long groupId, java.lang.String templateId,
3852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3853                    throws com.liferay.portal.kernel.exception.SystemException,
3854                            com.liferay.portlet.journal.NoSuchArticleException {
3855                    return getPersistence()
3856                                       .findByG_T_Last(groupId, templateId, orderByComparator);
3857            }
3858    
3859            /**
3860            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3861            *
3862            * @param groupId the group ID
3863            * @param templateId the template ID
3864            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3865            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3866            * @throws SystemException if a system exception occurred
3867            */
3868            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last(
3869                    long groupId, java.lang.String templateId,
3870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3871                    throws com.liferay.portal.kernel.exception.SystemException {
3872                    return getPersistence()
3873                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
3874            }
3875    
3876            /**
3877            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3878            *
3879            * @param id the primary key of the current journal article
3880            * @param groupId the group ID
3881            * @param templateId the template ID
3882            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3883            * @return the previous, current, and next journal article
3884            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3885            * @throws SystemException if a system exception occurred
3886            */
3887            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
3888                    long id, long groupId, java.lang.String templateId,
3889                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3890                    throws com.liferay.portal.kernel.exception.SystemException,
3891                            com.liferay.portlet.journal.NoSuchArticleException {
3892                    return getPersistence()
3893                                       .findByG_T_PrevAndNext(id, groupId, templateId,
3894                            orderByComparator);
3895            }
3896    
3897            /**
3898            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3899            *
3900            * @param groupId the group ID
3901            * @param templateId the template ID
3902            * @return the matching journal articles that the user has permission to view
3903            * @throws SystemException if a system exception occurred
3904            */
3905            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3906                    long groupId, java.lang.String templateId)
3907                    throws com.liferay.portal.kernel.exception.SystemException {
3908                    return getPersistence().filterFindByG_T(groupId, templateId);
3909            }
3910    
3911            /**
3912            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3913            *
3914            * <p>
3915            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3916            * </p>
3917            *
3918            * @param groupId the group ID
3919            * @param templateId the template ID
3920            * @param start the lower bound of the range of journal articles
3921            * @param end the upper bound of the range of journal articles (not inclusive)
3922            * @return the range of matching journal articles that the user has permission to view
3923            * @throws SystemException if a system exception occurred
3924            */
3925            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3926                    long groupId, java.lang.String templateId, int start, int end)
3927                    throws com.liferay.portal.kernel.exception.SystemException {
3928                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
3929            }
3930    
3931            /**
3932            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
3933            *
3934            * <p>
3935            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3936            * </p>
3937            *
3938            * @param groupId the group ID
3939            * @param templateId the template ID
3940            * @param start the lower bound of the range of journal articles
3941            * @param end the upper bound of the range of journal articles (not inclusive)
3942            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3943            * @return the ordered range of matching journal articles that the user has permission to view
3944            * @throws SystemException if a system exception occurred
3945            */
3946            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3947                    long groupId, java.lang.String templateId, int start, int end,
3948                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3949                    throws com.liferay.portal.kernel.exception.SystemException {
3950                    return getPersistence()
3951                                       .filterFindByG_T(groupId, templateId, start, end,
3952                            orderByComparator);
3953            }
3954    
3955            /**
3956            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3957            *
3958            * @param id the primary key of the current journal article
3959            * @param groupId the group ID
3960            * @param templateId the template ID
3961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3962            * @return the previous, current, and next journal article
3963            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3964            * @throws SystemException if a system exception occurred
3965            */
3966            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
3967                    long id, long groupId, java.lang.String templateId,
3968                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3969                    throws com.liferay.portal.kernel.exception.SystemException,
3970                            com.liferay.portlet.journal.NoSuchArticleException {
3971                    return getPersistence()
3972                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
3973                            orderByComparator);
3974            }
3975    
3976            /**
3977            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
3978            *
3979            * @param groupId the group ID
3980            * @param templateId the template ID
3981            * @throws SystemException if a system exception occurred
3982            */
3983            public static void removeByG_T(long groupId, java.lang.String templateId)
3984                    throws com.liferay.portal.kernel.exception.SystemException {
3985                    getPersistence().removeByG_T(groupId, templateId);
3986            }
3987    
3988            /**
3989            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
3990            *
3991            * @param groupId the group ID
3992            * @param templateId the template ID
3993            * @return the number of matching journal articles
3994            * @throws SystemException if a system exception occurred
3995            */
3996            public static int countByG_T(long groupId, java.lang.String templateId)
3997                    throws com.liferay.portal.kernel.exception.SystemException {
3998                    return getPersistence().countByG_T(groupId, templateId);
3999            }
4000    
4001            /**
4002            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
4003            *
4004            * @param groupId the group ID
4005            * @param templateId the template ID
4006            * @return the number of matching journal articles that the user has permission to view
4007            * @throws SystemException if a system exception occurred
4008            */
4009            public static int filterCountByG_T(long groupId, java.lang.String templateId)
4010                    throws com.liferay.portal.kernel.exception.SystemException {
4011                    return getPersistence().filterCountByG_T(groupId, templateId);
4012            }
4013    
4014            /**
4015            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
4016            *
4017            * @param groupId the group ID
4018            * @param layoutUuid the layout uuid
4019            * @return the matching journal articles
4020            * @throws SystemException if a system exception occurred
4021            */
4022            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
4023                    long groupId, java.lang.String layoutUuid)
4024                    throws com.liferay.portal.kernel.exception.SystemException {
4025                    return getPersistence().findByG_L(groupId, layoutUuid);
4026            }
4027    
4028            /**
4029            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
4030            *
4031            * <p>
4032            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4033            * </p>
4034            *
4035            * @param groupId the group ID
4036            * @param layoutUuid the layout uuid
4037            * @param start the lower bound of the range of journal articles
4038            * @param end the upper bound of the range of journal articles (not inclusive)
4039            * @return the range of matching journal articles
4040            * @throws SystemException if a system exception occurred
4041            */
4042            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
4043                    long groupId, java.lang.String layoutUuid, int start, int end)
4044                    throws com.liferay.portal.kernel.exception.SystemException {
4045                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
4046            }
4047    
4048            /**
4049            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
4050            *
4051            * <p>
4052            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4053            * </p>
4054            *
4055            * @param groupId the group ID
4056            * @param layoutUuid the layout uuid
4057            * @param start the lower bound of the range of journal articles
4058            * @param end the upper bound of the range of journal articles (not inclusive)
4059            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4060            * @return the ordered range of matching journal articles
4061            * @throws SystemException if a system exception occurred
4062            */
4063            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
4064                    long groupId, java.lang.String layoutUuid, int start, int end,
4065                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4066                    throws com.liferay.portal.kernel.exception.SystemException {
4067                    return getPersistence()
4068                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
4069            }
4070    
4071            /**
4072            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4073            *
4074            * @param groupId the group ID
4075            * @param layoutUuid the layout uuid
4076            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4077            * @return the first matching journal article
4078            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4079            * @throws SystemException if a system exception occurred
4080            */
4081            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
4082                    long groupId, java.lang.String layoutUuid,
4083                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4084                    throws com.liferay.portal.kernel.exception.SystemException,
4085                            com.liferay.portlet.journal.NoSuchArticleException {
4086                    return getPersistence()
4087                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
4088            }
4089    
4090            /**
4091            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4092            *
4093            * @param groupId the group ID
4094            * @param layoutUuid the layout uuid
4095            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4096            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4097            * @throws SystemException if a system exception occurred
4098            */
4099            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
4100                    long groupId, java.lang.String layoutUuid,
4101                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4102                    throws com.liferay.portal.kernel.exception.SystemException {
4103                    return getPersistence()
4104                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
4105            }
4106    
4107            /**
4108            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4109            *
4110            * @param groupId the group ID
4111            * @param layoutUuid the layout uuid
4112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4113            * @return the last matching journal article
4114            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4115            * @throws SystemException if a system exception occurred
4116            */
4117            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
4118                    long groupId, java.lang.String layoutUuid,
4119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4120                    throws com.liferay.portal.kernel.exception.SystemException,
4121                            com.liferay.portlet.journal.NoSuchArticleException {
4122                    return getPersistence()
4123                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
4124            }
4125    
4126            /**
4127            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4128            *
4129            * @param groupId the group ID
4130            * @param layoutUuid the layout uuid
4131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4132            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4133            * @throws SystemException if a system exception occurred
4134            */
4135            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
4136                    long groupId, java.lang.String layoutUuid,
4137                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4138                    throws com.liferay.portal.kernel.exception.SystemException {
4139                    return getPersistence()
4140                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
4141            }
4142    
4143            /**
4144            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
4145            *
4146            * @param id the primary key of the current journal article
4147            * @param groupId the group ID
4148            * @param layoutUuid the layout uuid
4149            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4150            * @return the previous, current, and next journal article
4151            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4152            * @throws SystemException if a system exception occurred
4153            */
4154            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
4155                    long id, long groupId, java.lang.String layoutUuid,
4156                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4157                    throws com.liferay.portal.kernel.exception.SystemException,
4158                            com.liferay.portlet.journal.NoSuchArticleException {
4159                    return getPersistence()
4160                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
4161                            orderByComparator);
4162            }
4163    
4164            /**
4165            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4166            *
4167            * @param groupId the group ID
4168            * @param layoutUuid the layout uuid
4169            * @return the matching journal articles that the user has permission to view
4170            * @throws SystemException if a system exception occurred
4171            */
4172            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
4173                    long groupId, java.lang.String layoutUuid)
4174                    throws com.liferay.portal.kernel.exception.SystemException {
4175                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
4176            }
4177    
4178            /**
4179            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4180            *
4181            * <p>
4182            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4183            * </p>
4184            *
4185            * @param groupId the group ID
4186            * @param layoutUuid the layout uuid
4187            * @param start the lower bound of the range of journal articles
4188            * @param end the upper bound of the range of journal articles (not inclusive)
4189            * @return the range of matching journal articles that the user has permission to view
4190            * @throws SystemException if a system exception occurred
4191            */
4192            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
4193                    long groupId, java.lang.String layoutUuid, int start, int end)
4194                    throws com.liferay.portal.kernel.exception.SystemException {
4195                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
4196            }
4197    
4198            /**
4199            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
4200            *
4201            * <p>
4202            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4203            * </p>
4204            *
4205            * @param groupId the group ID
4206            * @param layoutUuid the layout uuid
4207            * @param start the lower bound of the range of journal articles
4208            * @param end the upper bound of the range of journal articles (not inclusive)
4209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4210            * @return the ordered range of matching journal articles that the user has permission to view
4211            * @throws SystemException if a system exception occurred
4212            */
4213            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
4214                    long groupId, java.lang.String layoutUuid, int start, int end,
4215                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4216                    throws com.liferay.portal.kernel.exception.SystemException {
4217                    return getPersistence()
4218                                       .filterFindByG_L(groupId, layoutUuid, start, end,
4219                            orderByComparator);
4220            }
4221    
4222            /**
4223            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4224            *
4225            * @param id the primary key of the current journal article
4226            * @param groupId the group ID
4227            * @param layoutUuid the layout uuid
4228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4229            * @return the previous, current, and next journal article
4230            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4231            * @throws SystemException if a system exception occurred
4232            */
4233            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
4234                    long id, long groupId, java.lang.String layoutUuid,
4235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4236                    throws com.liferay.portal.kernel.exception.SystemException,
4237                            com.liferay.portlet.journal.NoSuchArticleException {
4238                    return getPersistence()
4239                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
4240                            orderByComparator);
4241            }
4242    
4243            /**
4244            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
4245            *
4246            * @param groupId the group ID
4247            * @param layoutUuid the layout uuid
4248            * @throws SystemException if a system exception occurred
4249            */
4250            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
4251                    throws com.liferay.portal.kernel.exception.SystemException {
4252                    getPersistence().removeByG_L(groupId, layoutUuid);
4253            }
4254    
4255            /**
4256            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4257            *
4258            * @param groupId the group ID
4259            * @param layoutUuid the layout uuid
4260            * @return the number of matching journal articles
4261            * @throws SystemException if a system exception occurred
4262            */
4263            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4264                    throws com.liferay.portal.kernel.exception.SystemException {
4265                    return getPersistence().countByG_L(groupId, layoutUuid);
4266            }
4267    
4268            /**
4269            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4270            *
4271            * @param groupId the group ID
4272            * @param layoutUuid the layout uuid
4273            * @return the number of matching journal articles that the user has permission to view
4274            * @throws SystemException if a system exception occurred
4275            */
4276            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4277                    throws com.liferay.portal.kernel.exception.SystemException {
4278                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4279            }
4280    
4281            /**
4282            * Returns all the journal articles where groupId = &#63; and layoutUuid &ne; &#63;.
4283            *
4284            * @param groupId the group ID
4285            * @param layoutUuid the layout uuid
4286            * @return the matching journal articles
4287            * @throws SystemException if a system exception occurred
4288            */
4289            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL(
4290                    long groupId, java.lang.String layoutUuid)
4291                    throws com.liferay.portal.kernel.exception.SystemException {
4292                    return getPersistence().findByG_NotL(groupId, layoutUuid);
4293            }
4294    
4295            /**
4296            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid &ne; &#63;.
4297            *
4298            * <p>
4299            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4300            * </p>
4301            *
4302            * @param groupId the group ID
4303            * @param layoutUuid the layout uuid
4304            * @param start the lower bound of the range of journal articles
4305            * @param end the upper bound of the range of journal articles (not inclusive)
4306            * @return the range of matching journal articles
4307            * @throws SystemException if a system exception occurred
4308            */
4309            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL(
4310                    long groupId, java.lang.String layoutUuid, int start, int end)
4311                    throws com.liferay.portal.kernel.exception.SystemException {
4312                    return getPersistence().findByG_NotL(groupId, layoutUuid, start, end);
4313            }
4314    
4315            /**
4316            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid &ne; &#63;.
4317            *
4318            * <p>
4319            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4320            * </p>
4321            *
4322            * @param groupId the group ID
4323            * @param layoutUuid the layout uuid
4324            * @param start the lower bound of the range of journal articles
4325            * @param end the upper bound of the range of journal articles (not inclusive)
4326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4327            * @return the ordered range of matching journal articles
4328            * @throws SystemException if a system exception occurred
4329            */
4330            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL(
4331                    long groupId, java.lang.String layoutUuid, int start, int end,
4332                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4333                    throws com.liferay.portal.kernel.exception.SystemException {
4334                    return getPersistence()
4335                                       .findByG_NotL(groupId, layoutUuid, start, end,
4336                            orderByComparator);
4337            }
4338    
4339            /**
4340            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid &ne; &#63;.
4341            *
4342            * @param groupId the group ID
4343            * @param layoutUuid the layout uuid
4344            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4345            * @return the first matching journal article
4346            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4347            * @throws SystemException if a system exception occurred
4348            */
4349            public static com.liferay.portlet.journal.model.JournalArticle findByG_NotL_First(
4350                    long groupId, java.lang.String layoutUuid,
4351                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4352                    throws com.liferay.portal.kernel.exception.SystemException,
4353                            com.liferay.portlet.journal.NoSuchArticleException {
4354                    return getPersistence()
4355                                       .findByG_NotL_First(groupId, layoutUuid, orderByComparator);
4356            }
4357    
4358            /**
4359            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid &ne; &#63;.
4360            *
4361            * @param groupId the group ID
4362            * @param layoutUuid the layout uuid
4363            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4364            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4365            * @throws SystemException if a system exception occurred
4366            */
4367            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_NotL_First(
4368                    long groupId, java.lang.String layoutUuid,
4369                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4370                    throws com.liferay.portal.kernel.exception.SystemException {
4371                    return getPersistence()
4372                                       .fetchByG_NotL_First(groupId, layoutUuid, orderByComparator);
4373            }
4374    
4375            /**
4376            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid &ne; &#63;.
4377            *
4378            * @param groupId the group ID
4379            * @param layoutUuid the layout uuid
4380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4381            * @return the last matching journal article
4382            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4383            * @throws SystemException if a system exception occurred
4384            */
4385            public static com.liferay.portlet.journal.model.JournalArticle findByG_NotL_Last(
4386                    long groupId, java.lang.String layoutUuid,
4387                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4388                    throws com.liferay.portal.kernel.exception.SystemException,
4389                            com.liferay.portlet.journal.NoSuchArticleException {
4390                    return getPersistence()
4391                                       .findByG_NotL_Last(groupId, layoutUuid, orderByComparator);
4392            }
4393    
4394            /**
4395            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid &ne; &#63;.
4396            *
4397            * @param groupId the group ID
4398            * @param layoutUuid the layout uuid
4399            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4400            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4401            * @throws SystemException if a system exception occurred
4402            */
4403            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_NotL_Last(
4404                    long groupId, java.lang.String layoutUuid,
4405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4406                    throws com.liferay.portal.kernel.exception.SystemException {
4407                    return getPersistence()
4408                                       .fetchByG_NotL_Last(groupId, layoutUuid, orderByComparator);
4409            }
4410    
4411            /**
4412            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid &ne; &#63;.
4413            *
4414            * @param id the primary key of the current journal article
4415            * @param groupId the group ID
4416            * @param layoutUuid the layout uuid
4417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4418            * @return the previous, current, and next journal article
4419            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4420            * @throws SystemException if a system exception occurred
4421            */
4422            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_NotL_PrevAndNext(
4423                    long id, long groupId, java.lang.String layoutUuid,
4424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4425                    throws com.liferay.portal.kernel.exception.SystemException,
4426                            com.liferay.portlet.journal.NoSuchArticleException {
4427                    return getPersistence()
4428                                       .findByG_NotL_PrevAndNext(id, groupId, layoutUuid,
4429                            orderByComparator);
4430            }
4431    
4432            /**
4433            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; &#63;.
4434            *
4435            * @param groupId the group ID
4436            * @param layoutUuid the layout uuid
4437            * @return the matching journal articles that the user has permission to view
4438            * @throws SystemException if a system exception occurred
4439            */
4440            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL(
4441                    long groupId, java.lang.String layoutUuid)
4442                    throws com.liferay.portal.kernel.exception.SystemException {
4443                    return getPersistence().filterFindByG_NotL(groupId, layoutUuid);
4444            }
4445    
4446            /**
4447            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; &#63;.
4448            *
4449            * <p>
4450            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4451            * </p>
4452            *
4453            * @param groupId the group ID
4454            * @param layoutUuid the layout uuid
4455            * @param start the lower bound of the range of journal articles
4456            * @param end the upper bound of the range of journal articles (not inclusive)
4457            * @return the range of matching journal articles that the user has permission to view
4458            * @throws SystemException if a system exception occurred
4459            */
4460            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL(
4461                    long groupId, java.lang.String layoutUuid, int start, int end)
4462                    throws com.liferay.portal.kernel.exception.SystemException {
4463                    return getPersistence()
4464                                       .filterFindByG_NotL(groupId, layoutUuid, start, end);
4465            }
4466    
4467            /**
4468            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid &ne; &#63;.
4469            *
4470            * <p>
4471            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4472            * </p>
4473            *
4474            * @param groupId the group ID
4475            * @param layoutUuid the layout uuid
4476            * @param start the lower bound of the range of journal articles
4477            * @param end the upper bound of the range of journal articles (not inclusive)
4478            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4479            * @return the ordered range of matching journal articles that the user has permission to view
4480            * @throws SystemException if a system exception occurred
4481            */
4482            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL(
4483                    long groupId, java.lang.String layoutUuid, int start, int end,
4484                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4485                    throws com.liferay.portal.kernel.exception.SystemException {
4486                    return getPersistence()
4487                                       .filterFindByG_NotL(groupId, layoutUuid, start, end,
4488                            orderByComparator);
4489            }
4490    
4491            /**
4492            * 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 &ne; &#63;.
4493            *
4494            * @param id the primary key of the current journal article
4495            * @param groupId the group ID
4496            * @param layoutUuid the layout uuid
4497            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4498            * @return the previous, current, and next journal article
4499            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4500            * @throws SystemException if a system exception occurred
4501            */
4502            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_NotL_PrevAndNext(
4503                    long id, long groupId, java.lang.String layoutUuid,
4504                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4505                    throws com.liferay.portal.kernel.exception.SystemException,
4506                            com.liferay.portlet.journal.NoSuchArticleException {
4507                    return getPersistence()
4508                                       .filterFindByG_NotL_PrevAndNext(id, groupId, layoutUuid,
4509                            orderByComparator);
4510            }
4511    
4512            /**
4513            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; all &#63;.
4514            *
4515            * @param groupId the group ID
4516            * @param layoutUuids the layout uuids
4517            * @return the matching journal articles that the user has permission to view
4518            * @throws SystemException if a system exception occurred
4519            */
4520            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL(
4521                    long groupId, java.lang.String[] layoutUuids)
4522                    throws com.liferay.portal.kernel.exception.SystemException {
4523                    return getPersistence().filterFindByG_NotL(groupId, layoutUuids);
4524            }
4525    
4526            /**
4527            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; all &#63;.
4528            *
4529            * <p>
4530            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4531            * </p>
4532            *
4533            * @param groupId the group ID
4534            * @param layoutUuids the layout uuids
4535            * @param start the lower bound of the range of journal articles
4536            * @param end the upper bound of the range of journal articles (not inclusive)
4537            * @return the range of matching journal articles that the user has permission to view
4538            * @throws SystemException if a system exception occurred
4539            */
4540            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL(
4541                    long groupId, java.lang.String[] layoutUuids, int start, int end)
4542                    throws com.liferay.portal.kernel.exception.SystemException {
4543                    return getPersistence()
4544                                       .filterFindByG_NotL(groupId, layoutUuids, start, end);
4545            }
4546    
4547            /**
4548            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; all &#63;.
4549            *
4550            * <p>
4551            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4552            * </p>
4553            *
4554            * @param groupId the group ID
4555            * @param layoutUuids the layout uuids
4556            * @param start the lower bound of the range of journal articles
4557            * @param end the upper bound of the range of journal articles (not inclusive)
4558            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4559            * @return the ordered range of matching journal articles that the user has permission to view
4560            * @throws SystemException if a system exception occurred
4561            */
4562            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL(
4563                    long groupId, java.lang.String[] layoutUuids, int start, int end,
4564                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4565                    throws com.liferay.portal.kernel.exception.SystemException {
4566                    return getPersistence()
4567                                       .filterFindByG_NotL(groupId, layoutUuids, start, end,
4568                            orderByComparator);
4569            }
4570    
4571            /**
4572            * Returns all the journal articles where groupId = &#63; and layoutUuid &ne; all &#63;.
4573            *
4574            * <p>
4575            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4576            * </p>
4577            *
4578            * @param groupId the group ID
4579            * @param layoutUuids the layout uuids
4580            * @return the matching journal articles
4581            * @throws SystemException if a system exception occurred
4582            */
4583            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL(
4584                    long groupId, java.lang.String[] layoutUuids)
4585                    throws com.liferay.portal.kernel.exception.SystemException {
4586                    return getPersistence().findByG_NotL(groupId, layoutUuids);
4587            }
4588    
4589            /**
4590            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid &ne; all &#63;.
4591            *
4592            * <p>
4593            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4594            * </p>
4595            *
4596            * @param groupId the group ID
4597            * @param layoutUuids the layout uuids
4598            * @param start the lower bound of the range of journal articles
4599            * @param end the upper bound of the range of journal articles (not inclusive)
4600            * @return the range of matching journal articles
4601            * @throws SystemException if a system exception occurred
4602            */
4603            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL(
4604                    long groupId, java.lang.String[] layoutUuids, int start, int end)
4605                    throws com.liferay.portal.kernel.exception.SystemException {
4606                    return getPersistence().findByG_NotL(groupId, layoutUuids, start, end);
4607            }
4608    
4609            /**
4610            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid &ne; all &#63;.
4611            *
4612            * <p>
4613            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4614            * </p>
4615            *
4616            * @param groupId the group ID
4617            * @param layoutUuids the layout uuids
4618            * @param start the lower bound of the range of journal articles
4619            * @param end the upper bound of the range of journal articles (not inclusive)
4620            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4621            * @return the ordered range of matching journal articles
4622            * @throws SystemException if a system exception occurred
4623            */
4624            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL(
4625                    long groupId, java.lang.String[] layoutUuids, int start, int end,
4626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4627                    throws com.liferay.portal.kernel.exception.SystemException {
4628                    return getPersistence()
4629                                       .findByG_NotL(groupId, layoutUuids, start, end,
4630                            orderByComparator);
4631            }
4632    
4633            /**
4634            * Removes all the journal articles where groupId = &#63; and layoutUuid &ne; &#63; from the database.
4635            *
4636            * @param groupId the group ID
4637            * @param layoutUuid the layout uuid
4638            * @throws SystemException if a system exception occurred
4639            */
4640            public static void removeByG_NotL(long groupId, java.lang.String layoutUuid)
4641                    throws com.liferay.portal.kernel.exception.SystemException {
4642                    getPersistence().removeByG_NotL(groupId, layoutUuid);
4643            }
4644    
4645            /**
4646            * Returns the number of journal articles where groupId = &#63; and layoutUuid &ne; &#63;.
4647            *
4648            * @param groupId the group ID
4649            * @param layoutUuid the layout uuid
4650            * @return the number of matching journal articles
4651            * @throws SystemException if a system exception occurred
4652            */
4653            public static int countByG_NotL(long groupId, java.lang.String layoutUuid)
4654                    throws com.liferay.portal.kernel.exception.SystemException {
4655                    return getPersistence().countByG_NotL(groupId, layoutUuid);
4656            }
4657    
4658            /**
4659            * Returns the number of journal articles where groupId = &#63; and layoutUuid &ne; all &#63;.
4660            *
4661            * @param groupId the group ID
4662            * @param layoutUuids the layout uuids
4663            * @return the number of matching journal articles
4664            * @throws SystemException if a system exception occurred
4665            */
4666            public static int countByG_NotL(long groupId, java.lang.String[] layoutUuids)
4667                    throws com.liferay.portal.kernel.exception.SystemException {
4668                    return getPersistence().countByG_NotL(groupId, layoutUuids);
4669            }
4670    
4671            /**
4672            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; &#63;.
4673            *
4674            * @param groupId the group ID
4675            * @param layoutUuid the layout uuid
4676            * @return the number of matching journal articles that the user has permission to view
4677            * @throws SystemException if a system exception occurred
4678            */
4679            public static int filterCountByG_NotL(long groupId,
4680                    java.lang.String layoutUuid)
4681                    throws com.liferay.portal.kernel.exception.SystemException {
4682                    return getPersistence().filterCountByG_NotL(groupId, layoutUuid);
4683            }
4684    
4685            /**
4686            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid &ne; all &#63;.
4687            *
4688            * @param groupId the group ID
4689            * @param layoutUuids the layout uuids
4690            * @return the number of matching journal articles that the user has permission to view
4691            * @throws SystemException if a system exception occurred
4692            */
4693            public static int filterCountByG_NotL(long groupId,
4694                    java.lang.String[] layoutUuids)
4695                    throws com.liferay.portal.kernel.exception.SystemException {
4696                    return getPersistence().filterCountByG_NotL(groupId, layoutUuids);
4697            }
4698    
4699            /**
4700            * Returns all the journal articles where groupId = &#63; and status = &#63;.
4701            *
4702            * @param groupId the group ID
4703            * @param status the status
4704            * @return the matching journal articles
4705            * @throws SystemException if a system exception occurred
4706            */
4707            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4708                    long groupId, int status)
4709                    throws com.liferay.portal.kernel.exception.SystemException {
4710                    return getPersistence().findByG_ST(groupId, status);
4711            }
4712    
4713            /**
4714            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
4715            *
4716            * <p>
4717            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4718            * </p>
4719            *
4720            * @param groupId the group ID
4721            * @param status the status
4722            * @param start the lower bound of the range of journal articles
4723            * @param end the upper bound of the range of journal articles (not inclusive)
4724            * @return the range of matching journal articles
4725            * @throws SystemException if a system exception occurred
4726            */
4727            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4728                    long groupId, int status, int start, int end)
4729                    throws com.liferay.portal.kernel.exception.SystemException {
4730                    return getPersistence().findByG_ST(groupId, status, start, end);
4731            }
4732    
4733            /**
4734            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
4735            *
4736            * <p>
4737            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4738            * </p>
4739            *
4740            * @param groupId the group ID
4741            * @param status the status
4742            * @param start the lower bound of the range of journal articles
4743            * @param end the upper bound of the range of journal articles (not inclusive)
4744            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4745            * @return the ordered range of matching journal articles
4746            * @throws SystemException if a system exception occurred
4747            */
4748            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4749                    long groupId, int status, int start, int end,
4750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4751                    throws com.liferay.portal.kernel.exception.SystemException {
4752                    return getPersistence()
4753                                       .findByG_ST(groupId, status, start, end, orderByComparator);
4754            }
4755    
4756            /**
4757            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4758            *
4759            * @param groupId the group ID
4760            * @param status the status
4761            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4762            * @return the first matching journal article
4763            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4764            * @throws SystemException if a system exception occurred
4765            */
4766            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
4767                    long groupId, int status,
4768                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4769                    throws com.liferay.portal.kernel.exception.SystemException,
4770                            com.liferay.portlet.journal.NoSuchArticleException {
4771                    return getPersistence()
4772                                       .findByG_ST_First(groupId, status, orderByComparator);
4773            }
4774    
4775            /**
4776            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4777            *
4778            * @param groupId the group ID
4779            * @param status the status
4780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4781            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4782            * @throws SystemException if a system exception occurred
4783            */
4784            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
4785                    long groupId, int status,
4786                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4787                    throws com.liferay.portal.kernel.exception.SystemException {
4788                    return getPersistence()
4789                                       .fetchByG_ST_First(groupId, status, orderByComparator);
4790            }
4791    
4792            /**
4793            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4794            *
4795            * @param groupId the group ID
4796            * @param status the status
4797            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4798            * @return the last matching journal article
4799            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4800            * @throws SystemException if a system exception occurred
4801            */
4802            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
4803                    long groupId, int status,
4804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4805                    throws com.liferay.portal.kernel.exception.SystemException,
4806                            com.liferay.portlet.journal.NoSuchArticleException {
4807                    return getPersistence()
4808                                       .findByG_ST_Last(groupId, status, orderByComparator);
4809            }
4810    
4811            /**
4812            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4813            *
4814            * @param groupId the group ID
4815            * @param status the status
4816            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4817            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4818            * @throws SystemException if a system exception occurred
4819            */
4820            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last(
4821                    long groupId, int status,
4822                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4823                    throws com.liferay.portal.kernel.exception.SystemException {
4824                    return getPersistence()
4825                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
4826            }
4827    
4828            /**
4829            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
4830            *
4831            * @param id the primary key of the current journal article
4832            * @param groupId the group ID
4833            * @param status the status
4834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4835            * @return the previous, current, and next journal article
4836            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4837            * @throws SystemException if a system exception occurred
4838            */
4839            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
4840                    long id, long groupId, int status,
4841                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4842                    throws com.liferay.portal.kernel.exception.SystemException,
4843                            com.liferay.portlet.journal.NoSuchArticleException {
4844                    return getPersistence()
4845                                       .findByG_ST_PrevAndNext(id, groupId, status,
4846                            orderByComparator);
4847            }
4848    
4849            /**
4850            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4851            *
4852            * @param groupId the group ID
4853            * @param status the status
4854            * @return the matching journal articles that the user has permission to view
4855            * @throws SystemException if a system exception occurred
4856            */
4857            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4858                    long groupId, int status)
4859                    throws com.liferay.portal.kernel.exception.SystemException {
4860                    return getPersistence().filterFindByG_ST(groupId, status);
4861            }
4862    
4863            /**
4864            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4865            *
4866            * <p>
4867            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4868            * </p>
4869            *
4870            * @param groupId the group ID
4871            * @param status the status
4872            * @param start the lower bound of the range of journal articles
4873            * @param end the upper bound of the range of journal articles (not inclusive)
4874            * @return the range of matching journal articles that the user has permission to view
4875            * @throws SystemException if a system exception occurred
4876            */
4877            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4878                    long groupId, int status, int start, int end)
4879                    throws com.liferay.portal.kernel.exception.SystemException {
4880                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
4881            }
4882    
4883            /**
4884            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
4885            *
4886            * <p>
4887            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4888            * </p>
4889            *
4890            * @param groupId the group ID
4891            * @param status the status
4892            * @param start the lower bound of the range of journal articles
4893            * @param end the upper bound of the range of journal articles (not inclusive)
4894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4895            * @return the ordered range of matching journal articles that the user has permission to view
4896            * @throws SystemException if a system exception occurred
4897            */
4898            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4899                    long groupId, int status, int start, int end,
4900                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4901                    throws com.liferay.portal.kernel.exception.SystemException {
4902                    return getPersistence()
4903                                       .filterFindByG_ST(groupId, status, start, end,
4904                            orderByComparator);
4905            }
4906    
4907            /**
4908            * 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;.
4909            *
4910            * @param id the primary key of the current journal article
4911            * @param groupId the group ID
4912            * @param status the status
4913            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4914            * @return the previous, current, and next journal article
4915            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4916            * @throws SystemException if a system exception occurred
4917            */
4918            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
4919                    long id, long groupId, int status,
4920                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4921                    throws com.liferay.portal.kernel.exception.SystemException,
4922                            com.liferay.portlet.journal.NoSuchArticleException {
4923                    return getPersistence()
4924                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
4925                            orderByComparator);
4926            }
4927    
4928            /**
4929            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4930            *
4931            * @param groupId the group ID
4932            * @param status the status
4933            * @throws SystemException if a system exception occurred
4934            */
4935            public static void removeByG_ST(long groupId, int status)
4936                    throws com.liferay.portal.kernel.exception.SystemException {
4937                    getPersistence().removeByG_ST(groupId, status);
4938            }
4939    
4940            /**
4941            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4942            *
4943            * @param groupId the group ID
4944            * @param status the status
4945            * @return the number of matching journal articles
4946            * @throws SystemException if a system exception occurred
4947            */
4948            public static int countByG_ST(long groupId, int status)
4949                    throws com.liferay.portal.kernel.exception.SystemException {
4950                    return getPersistence().countByG_ST(groupId, status);
4951            }
4952    
4953            /**
4954            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4955            *
4956            * @param groupId the group ID
4957            * @param status the status
4958            * @return the number of matching journal articles that the user has permission to view
4959            * @throws SystemException if a system exception occurred
4960            */
4961            public static int filterCountByG_ST(long groupId, int status)
4962                    throws com.liferay.portal.kernel.exception.SystemException {
4963                    return getPersistence().filterCountByG_ST(groupId, status);
4964            }
4965    
4966            /**
4967            * Returns all the journal articles where companyId = &#63; and version = &#63;.
4968            *
4969            * @param companyId the company ID
4970            * @param version the version
4971            * @return the matching journal articles
4972            * @throws SystemException if a system exception occurred
4973            */
4974            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4975                    long companyId, double version)
4976                    throws com.liferay.portal.kernel.exception.SystemException {
4977                    return getPersistence().findByC_V(companyId, version);
4978            }
4979    
4980            /**
4981            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4982            *
4983            * <p>
4984            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4985            * </p>
4986            *
4987            * @param companyId the company ID
4988            * @param version the version
4989            * @param start the lower bound of the range of journal articles
4990            * @param end the upper bound of the range of journal articles (not inclusive)
4991            * @return the range of matching journal articles
4992            * @throws SystemException if a system exception occurred
4993            */
4994            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4995                    long companyId, double version, int start, int end)
4996                    throws com.liferay.portal.kernel.exception.SystemException {
4997                    return getPersistence().findByC_V(companyId, version, start, end);
4998            }
4999    
5000            /**
5001            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
5002            *
5003            * <p>
5004            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5005            * </p>
5006            *
5007            * @param companyId the company ID
5008            * @param version the version
5009            * @param start the lower bound of the range of journal articles
5010            * @param end the upper bound of the range of journal articles (not inclusive)
5011            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5012            * @return the ordered range of matching journal articles
5013            * @throws SystemException if a system exception occurred
5014            */
5015            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
5016                    long companyId, double version, int start, int end,
5017                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5018                    throws com.liferay.portal.kernel.exception.SystemException {
5019                    return getPersistence()
5020                                       .findByC_V(companyId, version, start, end, orderByComparator);
5021            }
5022    
5023            /**
5024            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
5025            *
5026            * @param companyId the company ID
5027            * @param version the version
5028            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5029            * @return the first matching journal article
5030            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5031            * @throws SystemException if a system exception occurred
5032            */
5033            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
5034                    long companyId, double version,
5035                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5036                    throws com.liferay.portal.kernel.exception.SystemException,
5037                            com.liferay.portlet.journal.NoSuchArticleException {
5038                    return getPersistence()
5039                                       .findByC_V_First(companyId, version, orderByComparator);
5040            }
5041    
5042            /**
5043            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
5044            *
5045            * @param companyId the company ID
5046            * @param version the version
5047            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5048            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5049            * @throws SystemException if a system exception occurred
5050            */
5051            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
5052                    long companyId, double version,
5053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5054                    throws com.liferay.portal.kernel.exception.SystemException {
5055                    return getPersistence()
5056                                       .fetchByC_V_First(companyId, version, orderByComparator);
5057            }
5058    
5059            /**
5060            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
5061            *
5062            * @param companyId the company ID
5063            * @param version the version
5064            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5065            * @return the last matching journal article
5066            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5067            * @throws SystemException if a system exception occurred
5068            */
5069            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
5070                    long companyId, double version,
5071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5072                    throws com.liferay.portal.kernel.exception.SystemException,
5073                            com.liferay.portlet.journal.NoSuchArticleException {
5074                    return getPersistence()
5075                                       .findByC_V_Last(companyId, version, orderByComparator);
5076            }
5077    
5078            /**
5079            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
5080            *
5081            * @param companyId the company ID
5082            * @param version the version
5083            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5084            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5085            * @throws SystemException if a system exception occurred
5086            */
5087            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
5088                    long companyId, double version,
5089                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5090                    throws com.liferay.portal.kernel.exception.SystemException {
5091                    return getPersistence()
5092                                       .fetchByC_V_Last(companyId, version, orderByComparator);
5093            }
5094    
5095            /**
5096            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
5097            *
5098            * @param id the primary key of the current journal article
5099            * @param companyId the company ID
5100            * @param version the version
5101            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5102            * @return the previous, current, and next journal article
5103            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5104            * @throws SystemException if a system exception occurred
5105            */
5106            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
5107                    long id, long companyId, double version,
5108                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5109                    throws com.liferay.portal.kernel.exception.SystemException,
5110                            com.liferay.portlet.journal.NoSuchArticleException {
5111                    return getPersistence()
5112                                       .findByC_V_PrevAndNext(id, companyId, version,
5113                            orderByComparator);
5114            }
5115    
5116            /**
5117            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
5118            *
5119            * @param companyId the company ID
5120            * @param version the version
5121            * @throws SystemException if a system exception occurred
5122            */
5123            public static void removeByC_V(long companyId, double version)
5124                    throws com.liferay.portal.kernel.exception.SystemException {
5125                    getPersistence().removeByC_V(companyId, version);
5126            }
5127    
5128            /**
5129            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
5130            *
5131            * @param companyId the company ID
5132            * @param version the version
5133            * @return the number of matching journal articles
5134            * @throws SystemException if a system exception occurred
5135            */
5136            public static int countByC_V(long companyId, double version)
5137                    throws com.liferay.portal.kernel.exception.SystemException {
5138                    return getPersistence().countByC_V(companyId, version);
5139            }
5140    
5141            /**
5142            * Returns all the journal articles where companyId = &#63; and status = &#63;.
5143            *
5144            * @param companyId the company ID
5145            * @param status the status
5146            * @return the matching journal articles
5147            * @throws SystemException if a system exception occurred
5148            */
5149            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
5150                    long companyId, int status)
5151                    throws com.liferay.portal.kernel.exception.SystemException {
5152                    return getPersistence().findByC_ST(companyId, status);
5153            }
5154    
5155            /**
5156            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
5157            *
5158            * <p>
5159            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5160            * </p>
5161            *
5162            * @param companyId the company ID
5163            * @param status the status
5164            * @param start the lower bound of the range of journal articles
5165            * @param end the upper bound of the range of journal articles (not inclusive)
5166            * @return the range of matching journal articles
5167            * @throws SystemException if a system exception occurred
5168            */
5169            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
5170                    long companyId, int status, int start, int end)
5171                    throws com.liferay.portal.kernel.exception.SystemException {
5172                    return getPersistence().findByC_ST(companyId, status, start, end);
5173            }
5174    
5175            /**
5176            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
5177            *
5178            * <p>
5179            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5180            * </p>
5181            *
5182            * @param companyId the company ID
5183            * @param status the status
5184            * @param start the lower bound of the range of journal articles
5185            * @param end the upper bound of the range of journal articles (not inclusive)
5186            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5187            * @return the ordered range of matching journal articles
5188            * @throws SystemException if a system exception occurred
5189            */
5190            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
5191                    long companyId, int status, int start, int end,
5192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5193                    throws com.liferay.portal.kernel.exception.SystemException {
5194                    return getPersistence()
5195                                       .findByC_ST(companyId, status, start, end, orderByComparator);
5196            }
5197    
5198            /**
5199            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
5200            *
5201            * @param companyId the company ID
5202            * @param status the status
5203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5204            * @return the first matching journal article
5205            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5206            * @throws SystemException if a system exception occurred
5207            */
5208            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
5209                    long companyId, int status,
5210                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5211                    throws com.liferay.portal.kernel.exception.SystemException,
5212                            com.liferay.portlet.journal.NoSuchArticleException {
5213                    return getPersistence()
5214                                       .findByC_ST_First(companyId, status, orderByComparator);
5215            }
5216    
5217            /**
5218            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
5219            *
5220            * @param companyId the company ID
5221            * @param status the status
5222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5223            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5224            * @throws SystemException if a system exception occurred
5225            */
5226            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
5227                    long companyId, int status,
5228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5229                    throws com.liferay.portal.kernel.exception.SystemException {
5230                    return getPersistence()
5231                                       .fetchByC_ST_First(companyId, status, orderByComparator);
5232            }
5233    
5234            /**
5235            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
5236            *
5237            * @param companyId the company ID
5238            * @param status the status
5239            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5240            * @return the last matching journal article
5241            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5242            * @throws SystemException if a system exception occurred
5243            */
5244            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
5245                    long companyId, int status,
5246                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5247                    throws com.liferay.portal.kernel.exception.SystemException,
5248                            com.liferay.portlet.journal.NoSuchArticleException {
5249                    return getPersistence()
5250                                       .findByC_ST_Last(companyId, status, orderByComparator);
5251            }
5252    
5253            /**
5254            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
5255            *
5256            * @param companyId the company ID
5257            * @param status the status
5258            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5259            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5260            * @throws SystemException if a system exception occurred
5261            */
5262            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
5263                    long companyId, int status,
5264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5265                    throws com.liferay.portal.kernel.exception.SystemException {
5266                    return getPersistence()
5267                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
5268            }
5269    
5270            /**
5271            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
5272            *
5273            * @param id the primary key of the current journal article
5274            * @param companyId the company ID
5275            * @param status the status
5276            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5277            * @return the previous, current, and next journal article
5278            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5279            * @throws SystemException if a system exception occurred
5280            */
5281            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
5282                    long id, long companyId, int status,
5283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5284                    throws com.liferay.portal.kernel.exception.SystemException,
5285                            com.liferay.portlet.journal.NoSuchArticleException {
5286                    return getPersistence()
5287                                       .findByC_ST_PrevAndNext(id, companyId, status,
5288                            orderByComparator);
5289            }
5290    
5291            /**
5292            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
5293            *
5294            * @param companyId the company ID
5295            * @param status the status
5296            * @throws SystemException if a system exception occurred
5297            */
5298            public static void removeByC_ST(long companyId, int status)
5299                    throws com.liferay.portal.kernel.exception.SystemException {
5300                    getPersistence().removeByC_ST(companyId, status);
5301            }
5302    
5303            /**
5304            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
5305            *
5306            * @param companyId the company ID
5307            * @param status the status
5308            * @return the number of matching journal articles
5309            * @throws SystemException if a system exception occurred
5310            */
5311            public static int countByC_ST(long companyId, int status)
5312                    throws com.liferay.portal.kernel.exception.SystemException {
5313                    return getPersistence().countByC_ST(companyId, status);
5314            }
5315    
5316            /**
5317            * Returns all the journal articles where companyId = &#63; and status &ne; &#63;.
5318            *
5319            * @param companyId the company ID
5320            * @param status the status
5321            * @return the matching journal articles
5322            * @throws SystemException if a system exception occurred
5323            */
5324            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
5325                    long companyId, int status)
5326                    throws com.liferay.portal.kernel.exception.SystemException {
5327                    return getPersistence().findByC_NotST(companyId, status);
5328            }
5329    
5330            /**
5331            * Returns a range of all the journal articles where companyId = &#63; and status &ne; &#63;.
5332            *
5333            * <p>
5334            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5335            * </p>
5336            *
5337            * @param companyId the company ID
5338            * @param status the status
5339            * @param start the lower bound of the range of journal articles
5340            * @param end the upper bound of the range of journal articles (not inclusive)
5341            * @return the range of matching journal articles
5342            * @throws SystemException if a system exception occurred
5343            */
5344            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
5345                    long companyId, int status, int start, int end)
5346                    throws com.liferay.portal.kernel.exception.SystemException {
5347                    return getPersistence().findByC_NotST(companyId, status, start, end);
5348            }
5349    
5350            /**
5351            * Returns an ordered range of all the journal articles where companyId = &#63; and status &ne; &#63;.
5352            *
5353            * <p>
5354            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5355            * </p>
5356            *
5357            * @param companyId the company ID
5358            * @param status the status
5359            * @param start the lower bound of the range of journal articles
5360            * @param end the upper bound of the range of journal articles (not inclusive)
5361            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5362            * @return the ordered range of matching journal articles
5363            * @throws SystemException if a system exception occurred
5364            */
5365            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
5366                    long companyId, int status, int start, int end,
5367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5368                    throws com.liferay.portal.kernel.exception.SystemException {
5369                    return getPersistence()
5370                                       .findByC_NotST(companyId, status, start, end,
5371                            orderByComparator);
5372            }
5373    
5374            /**
5375            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5376            *
5377            * @param companyId the company ID
5378            * @param status the status
5379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5380            * @return the first matching journal article
5381            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5382            * @throws SystemException if a system exception occurred
5383            */
5384            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First(
5385                    long companyId, int status,
5386                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5387                    throws com.liferay.portal.kernel.exception.SystemException,
5388                            com.liferay.portlet.journal.NoSuchArticleException {
5389                    return getPersistence()
5390                                       .findByC_NotST_First(companyId, status, orderByComparator);
5391            }
5392    
5393            /**
5394            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5395            *
5396            * @param companyId the company ID
5397            * @param status the status
5398            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5399            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5400            * @throws SystemException if a system exception occurred
5401            */
5402            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First(
5403                    long companyId, int status,
5404                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5405                    throws com.liferay.portal.kernel.exception.SystemException {
5406                    return getPersistence()
5407                                       .fetchByC_NotST_First(companyId, status, orderByComparator);
5408            }
5409    
5410            /**
5411            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5412            *
5413            * @param companyId the company ID
5414            * @param status the status
5415            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5416            * @return the last matching journal article
5417            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5418            * @throws SystemException if a system exception occurred
5419            */
5420            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last(
5421                    long companyId, int status,
5422                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5423                    throws com.liferay.portal.kernel.exception.SystemException,
5424                            com.liferay.portlet.journal.NoSuchArticleException {
5425                    return getPersistence()
5426                                       .findByC_NotST_Last(companyId, status, orderByComparator);
5427            }
5428    
5429            /**
5430            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5431            *
5432            * @param companyId the company ID
5433            * @param status the status
5434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5435            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5436            * @throws SystemException if a system exception occurred
5437            */
5438            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last(
5439                    long companyId, int status,
5440                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5441                    throws com.liferay.portal.kernel.exception.SystemException {
5442                    return getPersistence()
5443                                       .fetchByC_NotST_Last(companyId, status, orderByComparator);
5444            }
5445    
5446            /**
5447            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
5448            *
5449            * @param id the primary key of the current journal article
5450            * @param companyId the company ID
5451            * @param status the status
5452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5453            * @return the previous, current, and next journal article
5454            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5455            * @throws SystemException if a system exception occurred
5456            */
5457            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext(
5458                    long id, long companyId, int status,
5459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5460                    throws com.liferay.portal.kernel.exception.SystemException,
5461                            com.liferay.portlet.journal.NoSuchArticleException {
5462                    return getPersistence()
5463                                       .findByC_NotST_PrevAndNext(id, companyId, status,
5464                            orderByComparator);
5465            }
5466    
5467            /**
5468            * Removes all the journal articles where companyId = &#63; and status &ne; &#63; from the database.
5469            *
5470            * @param companyId the company ID
5471            * @param status the status
5472            * @throws SystemException if a system exception occurred
5473            */
5474            public static void removeByC_NotST(long companyId, int status)
5475                    throws com.liferay.portal.kernel.exception.SystemException {
5476                    getPersistence().removeByC_NotST(companyId, status);
5477            }
5478    
5479            /**
5480            * Returns the number of journal articles where companyId = &#63; and status &ne; &#63;.
5481            *
5482            * @param companyId the company ID
5483            * @param status the status
5484            * @return the number of matching journal articles
5485            * @throws SystemException if a system exception occurred
5486            */
5487            public static int countByC_NotST(long companyId, int status)
5488                    throws com.liferay.portal.kernel.exception.SystemException {
5489                    return getPersistence().countByC_NotST(companyId, status);
5490            }
5491    
5492            /**
5493            * Returns all the journal articles where classNameId = &#63; and templateId = &#63;.
5494            *
5495            * @param classNameId the class name ID
5496            * @param templateId the template ID
5497            * @return the matching journal articles
5498            * @throws SystemException if a system exception occurred
5499            */
5500            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
5501                    long classNameId, java.lang.String templateId)
5502                    throws com.liferay.portal.kernel.exception.SystemException {
5503                    return getPersistence().findByC_T(classNameId, templateId);
5504            }
5505    
5506            /**
5507            * Returns a range of all the journal articles where classNameId = &#63; and templateId = &#63;.
5508            *
5509            * <p>
5510            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5511            * </p>
5512            *
5513            * @param classNameId the class name ID
5514            * @param templateId the template ID
5515            * @param start the lower bound of the range of journal articles
5516            * @param end the upper bound of the range of journal articles (not inclusive)
5517            * @return the range of matching journal articles
5518            * @throws SystemException if a system exception occurred
5519            */
5520            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
5521                    long classNameId, java.lang.String templateId, int start, int end)
5522                    throws com.liferay.portal.kernel.exception.SystemException {
5523                    return getPersistence().findByC_T(classNameId, templateId, start, end);
5524            }
5525    
5526            /**
5527            * Returns an ordered range of all the journal articles where classNameId = &#63; and templateId = &#63;.
5528            *
5529            * <p>
5530            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5531            * </p>
5532            *
5533            * @param classNameId the class name ID
5534            * @param templateId the template ID
5535            * @param start the lower bound of the range of journal articles
5536            * @param end the upper bound of the range of journal articles (not inclusive)
5537            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5538            * @return the ordered range of matching journal articles
5539            * @throws SystemException if a system exception occurred
5540            */
5541            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
5542                    long classNameId, java.lang.String templateId, int start, int end,
5543                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5544                    throws com.liferay.portal.kernel.exception.SystemException {
5545                    return getPersistence()
5546                                       .findByC_T(classNameId, templateId, start, end,
5547                            orderByComparator);
5548            }
5549    
5550            /**
5551            * Returns the first journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5552            *
5553            * @param classNameId the class name ID
5554            * @param templateId the template ID
5555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5556            * @return the first matching journal article
5557            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5558            * @throws SystemException if a system exception occurred
5559            */
5560            public static com.liferay.portlet.journal.model.JournalArticle findByC_T_First(
5561                    long classNameId, java.lang.String templateId,
5562                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5563                    throws com.liferay.portal.kernel.exception.SystemException,
5564                            com.liferay.portlet.journal.NoSuchArticleException {
5565                    return getPersistence()
5566                                       .findByC_T_First(classNameId, templateId, orderByComparator);
5567            }
5568    
5569            /**
5570            * Returns the first journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5571            *
5572            * @param classNameId the class name ID
5573            * @param templateId the template ID
5574            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5575            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5576            * @throws SystemException if a system exception occurred
5577            */
5578            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_First(
5579                    long classNameId, java.lang.String templateId,
5580                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5581                    throws com.liferay.portal.kernel.exception.SystemException {
5582                    return getPersistence()
5583                                       .fetchByC_T_First(classNameId, templateId, orderByComparator);
5584            }
5585    
5586            /**
5587            * Returns the last journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5588            *
5589            * @param classNameId the class name ID
5590            * @param templateId the template ID
5591            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5592            * @return the last matching journal article
5593            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5594            * @throws SystemException if a system exception occurred
5595            */
5596            public static com.liferay.portlet.journal.model.JournalArticle findByC_T_Last(
5597                    long classNameId, java.lang.String templateId,
5598                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5599                    throws com.liferay.portal.kernel.exception.SystemException,
5600                            com.liferay.portlet.journal.NoSuchArticleException {
5601                    return getPersistence()
5602                                       .findByC_T_Last(classNameId, templateId, orderByComparator);
5603            }
5604    
5605            /**
5606            * Returns the last journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5607            *
5608            * @param classNameId the class name ID
5609            * @param templateId the template ID
5610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5611            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5612            * @throws SystemException if a system exception occurred
5613            */
5614            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_Last(
5615                    long classNameId, java.lang.String templateId,
5616                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5617                    throws com.liferay.portal.kernel.exception.SystemException {
5618                    return getPersistence()
5619                                       .fetchByC_T_Last(classNameId, templateId, orderByComparator);
5620            }
5621    
5622            /**
5623            * Returns the journal articles before and after the current journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
5624            *
5625            * @param id the primary key of the current journal article
5626            * @param classNameId the class name ID
5627            * @param templateId the template ID
5628            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5629            * @return the previous, current, and next journal article
5630            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5631            * @throws SystemException if a system exception occurred
5632            */
5633            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_T_PrevAndNext(
5634                    long id, long classNameId, java.lang.String templateId,
5635                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5636                    throws com.liferay.portal.kernel.exception.SystemException,
5637                            com.liferay.portlet.journal.NoSuchArticleException {
5638                    return getPersistence()
5639                                       .findByC_T_PrevAndNext(id, classNameId, templateId,
5640                            orderByComparator);
5641            }
5642    
5643            /**
5644            * Removes all the journal articles where classNameId = &#63; and templateId = &#63; from the database.
5645            *
5646            * @param classNameId the class name ID
5647            * @param templateId the template ID
5648            * @throws SystemException if a system exception occurred
5649            */
5650            public static void removeByC_T(long classNameId, java.lang.String templateId)
5651                    throws com.liferay.portal.kernel.exception.SystemException {
5652                    getPersistence().removeByC_T(classNameId, templateId);
5653            }
5654    
5655            /**
5656            * Returns the number of journal articles where classNameId = &#63; and templateId = &#63;.
5657            *
5658            * @param classNameId the class name ID
5659            * @param templateId the template ID
5660            * @return the number of matching journal articles
5661            * @throws SystemException if a system exception occurred
5662            */
5663            public static int countByC_T(long classNameId, java.lang.String templateId)
5664                    throws com.liferay.portal.kernel.exception.SystemException {
5665                    return getPersistence().countByC_T(classNameId, templateId);
5666            }
5667    
5668            /**
5669            * Returns all the journal articles where displayDate &lt; &#63; and status = &#63;.
5670            *
5671            * @param displayDate the display date
5672            * @param status the status
5673            * @return the matching journal articles
5674            * @throws SystemException if a system exception occurred
5675            */
5676            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
5677                    java.util.Date displayDate, int status)
5678                    throws com.liferay.portal.kernel.exception.SystemException {
5679                    return getPersistence().findByLtD_S(displayDate, status);
5680            }
5681    
5682            /**
5683            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
5684            *
5685            * <p>
5686            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5687            * </p>
5688            *
5689            * @param displayDate the display date
5690            * @param status the status
5691            * @param start the lower bound of the range of journal articles
5692            * @param end the upper bound of the range of journal articles (not inclusive)
5693            * @return the range of matching journal articles
5694            * @throws SystemException if a system exception occurred
5695            */
5696            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
5697                    java.util.Date displayDate, int status, int start, int end)
5698                    throws com.liferay.portal.kernel.exception.SystemException {
5699                    return getPersistence().findByLtD_S(displayDate, status, start, end);
5700            }
5701    
5702            /**
5703            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
5704            *
5705            * <p>
5706            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5707            * </p>
5708            *
5709            * @param displayDate the display date
5710            * @param status the status
5711            * @param start the lower bound of the range of journal articles
5712            * @param end the upper bound of the range of journal articles (not inclusive)
5713            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5714            * @return the ordered range of matching journal articles
5715            * @throws SystemException if a system exception occurred
5716            */
5717            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
5718                    java.util.Date displayDate, int status, int start, int end,
5719                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5720                    throws com.liferay.portal.kernel.exception.SystemException {
5721                    return getPersistence()
5722                                       .findByLtD_S(displayDate, status, start, end,
5723                            orderByComparator);
5724            }
5725    
5726            /**
5727            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5728            *
5729            * @param displayDate the display date
5730            * @param status the status
5731            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5732            * @return the first matching journal article
5733            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5734            * @throws SystemException if a system exception occurred
5735            */
5736            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First(
5737                    java.util.Date displayDate, int status,
5738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5739                    throws com.liferay.portal.kernel.exception.SystemException,
5740                            com.liferay.portlet.journal.NoSuchArticleException {
5741                    return getPersistence()
5742                                       .findByLtD_S_First(displayDate, status, orderByComparator);
5743            }
5744    
5745            /**
5746            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5747            *
5748            * @param displayDate the display date
5749            * @param status the status
5750            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5751            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5752            * @throws SystemException if a system exception occurred
5753            */
5754            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First(
5755                    java.util.Date displayDate, int status,
5756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5757                    throws com.liferay.portal.kernel.exception.SystemException {
5758                    return getPersistence()
5759                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
5760            }
5761    
5762            /**
5763            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5764            *
5765            * @param displayDate the display date
5766            * @param status the status
5767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5768            * @return the last matching journal article
5769            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5770            * @throws SystemException if a system exception occurred
5771            */
5772            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last(
5773                    java.util.Date displayDate, int status,
5774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5775                    throws com.liferay.portal.kernel.exception.SystemException,
5776                            com.liferay.portlet.journal.NoSuchArticleException {
5777                    return getPersistence()
5778                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
5779            }
5780    
5781            /**
5782            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5783            *
5784            * @param displayDate the display date
5785            * @param status the status
5786            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5787            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5788            * @throws SystemException if a system exception occurred
5789            */
5790            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last(
5791                    java.util.Date displayDate, int status,
5792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5793                    throws com.liferay.portal.kernel.exception.SystemException {
5794                    return getPersistence()
5795                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
5796            }
5797    
5798            /**
5799            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
5800            *
5801            * @param id the primary key of the current journal article
5802            * @param displayDate the display date
5803            * @param status the status
5804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5805            * @return the previous, current, and next journal article
5806            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5807            * @throws SystemException if a system exception occurred
5808            */
5809            public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext(
5810                    long id, java.util.Date displayDate, int status,
5811                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5812                    throws com.liferay.portal.kernel.exception.SystemException,
5813                            com.liferay.portlet.journal.NoSuchArticleException {
5814                    return getPersistence()
5815                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
5816                            orderByComparator);
5817            }
5818    
5819            /**
5820            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
5821            *
5822            * @param displayDate the display date
5823            * @param status the status
5824            * @throws SystemException if a system exception occurred
5825            */
5826            public static void removeByLtD_S(java.util.Date displayDate, int status)
5827                    throws com.liferay.portal.kernel.exception.SystemException {
5828                    getPersistence().removeByLtD_S(displayDate, status);
5829            }
5830    
5831            /**
5832            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
5833            *
5834            * @param displayDate the display date
5835            * @param status the status
5836            * @return the number of matching journal articles
5837            * @throws SystemException if a system exception occurred
5838            */
5839            public static int countByLtD_S(java.util.Date displayDate, int status)
5840                    throws com.liferay.portal.kernel.exception.SystemException {
5841                    return getPersistence().countByLtD_S(displayDate, status);
5842            }
5843    
5844            /**
5845            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5846            *
5847            * @param resourcePrimKey the resource prim key
5848            * @param indexable the indexable
5849            * @param status the status
5850            * @return the matching journal articles
5851            * @throws SystemException if a system exception occurred
5852            */
5853            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5854                    long resourcePrimKey, boolean indexable, int status)
5855                    throws com.liferay.portal.kernel.exception.SystemException {
5856                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
5857            }
5858    
5859            /**
5860            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5861            *
5862            * <p>
5863            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5864            * </p>
5865            *
5866            * @param resourcePrimKey the resource prim key
5867            * @param indexable the indexable
5868            * @param status the status
5869            * @param start the lower bound of the range of journal articles
5870            * @param end the upper bound of the range of journal articles (not inclusive)
5871            * @return the range of matching journal articles
5872            * @throws SystemException if a system exception occurred
5873            */
5874            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5875                    long resourcePrimKey, boolean indexable, int status, int start, int end)
5876                    throws com.liferay.portal.kernel.exception.SystemException {
5877                    return getPersistence()
5878                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
5879            }
5880    
5881            /**
5882            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5883            *
5884            * <p>
5885            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5886            * </p>
5887            *
5888            * @param resourcePrimKey the resource prim key
5889            * @param indexable the indexable
5890            * @param status the status
5891            * @param start the lower bound of the range of journal articles
5892            * @param end the upper bound of the range of journal articles (not inclusive)
5893            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5894            * @return the ordered range of matching journal articles
5895            * @throws SystemException if a system exception occurred
5896            */
5897            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5898                    long resourcePrimKey, boolean indexable, int status, int start,
5899                    int end,
5900                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5901                    throws com.liferay.portal.kernel.exception.SystemException {
5902                    return getPersistence()
5903                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
5904                            orderByComparator);
5905            }
5906    
5907            /**
5908            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5909            *
5910            * @param resourcePrimKey the resource prim key
5911            * @param indexable the indexable
5912            * @param status the status
5913            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5914            * @return the first matching journal article
5915            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5916            * @throws SystemException if a system exception occurred
5917            */
5918            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First(
5919                    long resourcePrimKey, boolean indexable, int status,
5920                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5921                    throws com.liferay.portal.kernel.exception.SystemException,
5922                            com.liferay.portlet.journal.NoSuchArticleException {
5923                    return getPersistence()
5924                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
5925                            orderByComparator);
5926            }
5927    
5928            /**
5929            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5930            *
5931            * @param resourcePrimKey the resource prim key
5932            * @param indexable the indexable
5933            * @param status the status
5934            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5935            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5936            * @throws SystemException if a system exception occurred
5937            */
5938            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First(
5939                    long resourcePrimKey, boolean indexable, int status,
5940                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5941                    throws com.liferay.portal.kernel.exception.SystemException {
5942                    return getPersistence()
5943                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
5944                            orderByComparator);
5945            }
5946    
5947            /**
5948            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5949            *
5950            * @param resourcePrimKey the resource prim key
5951            * @param indexable the indexable
5952            * @param status the status
5953            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5954            * @return the last matching journal article
5955            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5956            * @throws SystemException if a system exception occurred
5957            */
5958            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last(
5959                    long resourcePrimKey, boolean indexable, int status,
5960                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5961                    throws com.liferay.portal.kernel.exception.SystemException,
5962                            com.liferay.portlet.journal.NoSuchArticleException {
5963                    return getPersistence()
5964                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
5965                            orderByComparator);
5966            }
5967    
5968            /**
5969            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5970            *
5971            * @param resourcePrimKey the resource prim key
5972            * @param indexable the indexable
5973            * @param status the status
5974            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5975            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5976            * @throws SystemException if a system exception occurred
5977            */
5978            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last(
5979                    long resourcePrimKey, boolean indexable, int status,
5980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5981                    throws com.liferay.portal.kernel.exception.SystemException {
5982                    return getPersistence()
5983                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
5984                            orderByComparator);
5985            }
5986    
5987            /**
5988            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5989            *
5990            * @param id the primary key of the current journal article
5991            * @param resourcePrimKey the resource prim key
5992            * @param indexable the indexable
5993            * @param status the status
5994            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5995            * @return the previous, current, and next journal article
5996            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5997            * @throws SystemException if a system exception occurred
5998            */
5999            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext(
6000                    long id, long resourcePrimKey, boolean indexable, int status,
6001                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6002                    throws com.liferay.portal.kernel.exception.SystemException,
6003                            com.liferay.portlet.journal.NoSuchArticleException {
6004                    return getPersistence()
6005                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
6006                            status, orderByComparator);
6007            }
6008    
6009            /**
6010            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
6011            *
6012            * <p>
6013            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6014            * </p>
6015            *
6016            * @param resourcePrimKey the resource prim key
6017            * @param indexable the indexable
6018            * @param statuses the statuses
6019            * @return the matching journal articles
6020            * @throws SystemException if a system exception occurred
6021            */
6022            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
6023                    long resourcePrimKey, boolean indexable, int[] statuses)
6024                    throws com.liferay.portal.kernel.exception.SystemException {
6025                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
6026            }
6027    
6028            /**
6029            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
6030            *
6031            * <p>
6032            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6033            * </p>
6034            *
6035            * @param resourcePrimKey the resource prim key
6036            * @param indexable the indexable
6037            * @param statuses the statuses
6038            * @param start the lower bound of the range of journal articles
6039            * @param end the upper bound of the range of journal articles (not inclusive)
6040            * @return the range of matching journal articles
6041            * @throws SystemException if a system exception occurred
6042            */
6043            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
6044                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
6045                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6046                    return getPersistence()
6047                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
6048            }
6049    
6050            /**
6051            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#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 resourcePrimKey the resource prim key
6058            * @param indexable the indexable
6059            * @param statuses the statuses
6060            * @param start the lower bound of the range of journal articles
6061            * @param end the upper bound of the range of journal articles (not inclusive)
6062            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6063            * @return the ordered range of matching journal articles
6064            * @throws SystemException if a system exception occurred
6065            */
6066            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
6067                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
6068                    int end,
6069                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6070                    throws com.liferay.portal.kernel.exception.SystemException {
6071                    return getPersistence()
6072                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
6073                            end, orderByComparator);
6074            }
6075    
6076            /**
6077            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
6078            *
6079            * @param resourcePrimKey the resource prim key
6080            * @param indexable the indexable
6081            * @param status the status
6082            * @throws SystemException if a system exception occurred
6083            */
6084            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
6085                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6086                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
6087            }
6088    
6089            /**
6090            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
6091            *
6092            * @param resourcePrimKey the resource prim key
6093            * @param indexable the indexable
6094            * @param status the status
6095            * @return the number of matching journal articles
6096            * @throws SystemException if a system exception occurred
6097            */
6098            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
6099                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6100                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
6101            }
6102    
6103            /**
6104            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
6105            *
6106            * @param resourcePrimKey the resource prim key
6107            * @param indexable the indexable
6108            * @param statuses the statuses
6109            * @return the number of matching journal articles
6110            * @throws SystemException if a system exception occurred
6111            */
6112            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
6113                    int[] statuses)
6114                    throws com.liferay.portal.kernel.exception.SystemException {
6115                    return getPersistence()
6116                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
6117            }
6118    
6119            /**
6120            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6121            *
6122            * @param groupId the group ID
6123            * @param userId the user ID
6124            * @param classNameId the class name ID
6125            * @return the matching journal articles
6126            * @throws SystemException if a system exception occurred
6127            */
6128            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6129                    long groupId, long userId, long classNameId)
6130                    throws com.liferay.portal.kernel.exception.SystemException {
6131                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
6132            }
6133    
6134            /**
6135            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6136            *
6137            * <p>
6138            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6139            * </p>
6140            *
6141            * @param groupId the group ID
6142            * @param userId the user ID
6143            * @param classNameId the class name ID
6144            * @param start the lower bound of the range of journal articles
6145            * @param end the upper bound of the range of journal articles (not inclusive)
6146            * @return the range of matching journal articles
6147            * @throws SystemException if a system exception occurred
6148            */
6149            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6150                    long groupId, long userId, long classNameId, int start, int end)
6151                    throws com.liferay.portal.kernel.exception.SystemException {
6152                    return getPersistence()
6153                                       .findByG_U_C(groupId, userId, classNameId, start, end);
6154            }
6155    
6156            /**
6157            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6158            *
6159            * <p>
6160            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6161            * </p>
6162            *
6163            * @param groupId the group ID
6164            * @param userId the user ID
6165            * @param classNameId the class name ID
6166            * @param start the lower bound of the range of journal articles
6167            * @param end the upper bound of the range of journal articles (not inclusive)
6168            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6169            * @return the ordered range of matching journal articles
6170            * @throws SystemException if a system exception occurred
6171            */
6172            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6173                    long groupId, long userId, long classNameId, int start, int end,
6174                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6175                    throws com.liferay.portal.kernel.exception.SystemException {
6176                    return getPersistence()
6177                                       .findByG_U_C(groupId, userId, classNameId, start, end,
6178                            orderByComparator);
6179            }
6180    
6181            /**
6182            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6183            *
6184            * @param groupId the group ID
6185            * @param userId the user ID
6186            * @param classNameId the class name ID
6187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6188            * @return the first matching journal article
6189            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6190            * @throws SystemException if a system exception occurred
6191            */
6192            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
6193                    long groupId, long userId, long classNameId,
6194                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6195                    throws com.liferay.portal.kernel.exception.SystemException,
6196                            com.liferay.portlet.journal.NoSuchArticleException {
6197                    return getPersistence()
6198                                       .findByG_U_C_First(groupId, userId, classNameId,
6199                            orderByComparator);
6200            }
6201    
6202            /**
6203            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6204            *
6205            * @param groupId the group ID
6206            * @param userId the user ID
6207            * @param classNameId the class name ID
6208            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6209            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6210            * @throws SystemException if a system exception occurred
6211            */
6212            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
6213                    long groupId, long userId, long classNameId,
6214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6215                    throws com.liferay.portal.kernel.exception.SystemException {
6216                    return getPersistence()
6217                                       .fetchByG_U_C_First(groupId, userId, classNameId,
6218                            orderByComparator);
6219            }
6220    
6221            /**
6222            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6223            *
6224            * @param groupId the group ID
6225            * @param userId the user ID
6226            * @param classNameId the class name ID
6227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6228            * @return the last matching journal article
6229            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6230            * @throws SystemException if a system exception occurred
6231            */
6232            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
6233                    long groupId, long userId, long classNameId,
6234                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6235                    throws com.liferay.portal.kernel.exception.SystemException,
6236                            com.liferay.portlet.journal.NoSuchArticleException {
6237                    return getPersistence()
6238                                       .findByG_U_C_Last(groupId, userId, classNameId,
6239                            orderByComparator);
6240            }
6241    
6242            /**
6243            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6244            *
6245            * @param groupId the group ID
6246            * @param userId the user ID
6247            * @param classNameId the class name ID
6248            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6249            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6250            * @throws SystemException if a system exception occurred
6251            */
6252            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
6253                    long groupId, long userId, long classNameId,
6254                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6255                    throws com.liferay.portal.kernel.exception.SystemException {
6256                    return getPersistence()
6257                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
6258                            orderByComparator);
6259            }
6260    
6261            /**
6262            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6263            *
6264            * @param id the primary key of the current journal article
6265            * @param groupId the group ID
6266            * @param userId the user ID
6267            * @param classNameId the class name ID
6268            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6269            * @return the previous, current, and next journal article
6270            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6271            * @throws SystemException if a system exception occurred
6272            */
6273            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
6274                    long id, long groupId, long userId, long classNameId,
6275                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6276                    throws com.liferay.portal.kernel.exception.SystemException,
6277                            com.liferay.portlet.journal.NoSuchArticleException {
6278                    return getPersistence()
6279                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
6280                            orderByComparator);
6281            }
6282    
6283            /**
6284            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6285            *
6286            * @param groupId the group ID
6287            * @param userId the user ID
6288            * @param classNameId the class name ID
6289            * @return the matching journal articles that the user has permission to view
6290            * @throws SystemException if a system exception occurred
6291            */
6292            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6293                    long groupId, long userId, long classNameId)
6294                    throws com.liferay.portal.kernel.exception.SystemException {
6295                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
6296            }
6297    
6298            /**
6299            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6300            *
6301            * <p>
6302            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6303            * </p>
6304            *
6305            * @param groupId the group ID
6306            * @param userId the user ID
6307            * @param classNameId the class name ID
6308            * @param start the lower bound of the range of journal articles
6309            * @param end the upper bound of the range of journal articles (not inclusive)
6310            * @return the range of matching journal articles that the user has permission to view
6311            * @throws SystemException if a system exception occurred
6312            */
6313            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6314                    long groupId, long userId, long classNameId, int start, int end)
6315                    throws com.liferay.portal.kernel.exception.SystemException {
6316                    return getPersistence()
6317                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
6318            }
6319    
6320            /**
6321            * 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;.
6322            *
6323            * <p>
6324            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6325            * </p>
6326            *
6327            * @param groupId the group ID
6328            * @param userId the user ID
6329            * @param classNameId the class name ID
6330            * @param start the lower bound of the range of journal articles
6331            * @param end the upper bound of the range of journal articles (not inclusive)
6332            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6333            * @return the ordered range of matching journal articles that the user has permission to view
6334            * @throws SystemException if a system exception occurred
6335            */
6336            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6337                    long groupId, long userId, long classNameId, int start, int end,
6338                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6339                    throws com.liferay.portal.kernel.exception.SystemException {
6340                    return getPersistence()
6341                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
6342                            orderByComparator);
6343            }
6344    
6345            /**
6346            * 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;.
6347            *
6348            * @param id the primary key of the current journal article
6349            * @param groupId the group ID
6350            * @param userId the user ID
6351            * @param classNameId the class name ID
6352            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6353            * @return the previous, current, and next journal article
6354            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6355            * @throws SystemException if a system exception occurred
6356            */
6357            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
6358                    long id, long groupId, long userId, long classNameId,
6359                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6360                    throws com.liferay.portal.kernel.exception.SystemException,
6361                            com.liferay.portlet.journal.NoSuchArticleException {
6362                    return getPersistence()
6363                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
6364                            classNameId, orderByComparator);
6365            }
6366    
6367            /**
6368            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
6369            *
6370            * @param groupId the group ID
6371            * @param userId the user ID
6372            * @param classNameId the class name ID
6373            * @throws SystemException if a system exception occurred
6374            */
6375            public static void removeByG_U_C(long groupId, long userId, long classNameId)
6376                    throws com.liferay.portal.kernel.exception.SystemException {
6377                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
6378            }
6379    
6380            /**
6381            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6382            *
6383            * @param groupId the group ID
6384            * @param userId the user ID
6385            * @param classNameId the class name ID
6386            * @return the number of matching journal articles
6387            * @throws SystemException if a system exception occurred
6388            */
6389            public static int countByG_U_C(long groupId, long userId, long classNameId)
6390                    throws com.liferay.portal.kernel.exception.SystemException {
6391                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
6392            }
6393    
6394            /**
6395            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6396            *
6397            * @param groupId the group ID
6398            * @param userId the user ID
6399            * @param classNameId the class name ID
6400            * @return the number of matching journal articles that the user has permission to view
6401            * @throws SystemException if a system exception occurred
6402            */
6403            public static int filterCountByG_U_C(long groupId, long userId,
6404                    long classNameId)
6405                    throws com.liferay.portal.kernel.exception.SystemException {
6406                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
6407            }
6408    
6409            /**
6410            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6411            *
6412            * @param groupId the group ID
6413            * @param folderId the folder ID
6414            * @param status the status
6415            * @return the matching journal articles
6416            * @throws SystemException if a system exception occurred
6417            */
6418            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6419                    long groupId, long folderId, int status)
6420                    throws com.liferay.portal.kernel.exception.SystemException {
6421                    return getPersistence().findByG_F_ST(groupId, folderId, status);
6422            }
6423    
6424            /**
6425            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6426            *
6427            * <p>
6428            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6429            * </p>
6430            *
6431            * @param groupId the group ID
6432            * @param folderId the folder ID
6433            * @param status the status
6434            * @param start the lower bound of the range of journal articles
6435            * @param end the upper bound of the range of journal articles (not inclusive)
6436            * @return the range of matching journal articles
6437            * @throws SystemException if a system exception occurred
6438            */
6439            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6440                    long groupId, long folderId, int status, int start, int end)
6441                    throws com.liferay.portal.kernel.exception.SystemException {
6442                    return getPersistence()
6443                                       .findByG_F_ST(groupId, folderId, status, start, end);
6444            }
6445    
6446            /**
6447            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6448            *
6449            * <p>
6450            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6451            * </p>
6452            *
6453            * @param groupId the group ID
6454            * @param folderId the folder ID
6455            * @param status the status
6456            * @param start the lower bound of the range of journal articles
6457            * @param end the upper bound of the range of journal articles (not inclusive)
6458            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6459            * @return the ordered range of matching journal articles
6460            * @throws SystemException if a system exception occurred
6461            */
6462            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6463                    long groupId, long folderId, int status, int start, int end,
6464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6465                    throws com.liferay.portal.kernel.exception.SystemException {
6466                    return getPersistence()
6467                                       .findByG_F_ST(groupId, folderId, status, start, end,
6468                            orderByComparator);
6469            }
6470    
6471            /**
6472            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6473            *
6474            * @param groupId the group ID
6475            * @param folderId the folder ID
6476            * @param status the status
6477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6478            * @return the first matching journal article
6479            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6480            * @throws SystemException if a system exception occurred
6481            */
6482            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
6483                    long groupId, long folderId, int status,
6484                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6485                    throws com.liferay.portal.kernel.exception.SystemException,
6486                            com.liferay.portlet.journal.NoSuchArticleException {
6487                    return getPersistence()
6488                                       .findByG_F_ST_First(groupId, folderId, status,
6489                            orderByComparator);
6490            }
6491    
6492            /**
6493            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6494            *
6495            * @param groupId the group ID
6496            * @param folderId the folder ID
6497            * @param status the status
6498            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6499            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6500            * @throws SystemException if a system exception occurred
6501            */
6502            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
6503                    long groupId, long folderId, int status,
6504                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6505                    throws com.liferay.portal.kernel.exception.SystemException {
6506                    return getPersistence()
6507                                       .fetchByG_F_ST_First(groupId, folderId, status,
6508                            orderByComparator);
6509            }
6510    
6511            /**
6512            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6513            *
6514            * @param groupId the group ID
6515            * @param folderId the folder ID
6516            * @param status the status
6517            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6518            * @return the last matching journal article
6519            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6520            * @throws SystemException if a system exception occurred
6521            */
6522            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
6523                    long groupId, long folderId, int status,
6524                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6525                    throws com.liferay.portal.kernel.exception.SystemException,
6526                            com.liferay.portlet.journal.NoSuchArticleException {
6527                    return getPersistence()
6528                                       .findByG_F_ST_Last(groupId, folderId, status,
6529                            orderByComparator);
6530            }
6531    
6532            /**
6533            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6534            *
6535            * @param groupId the group ID
6536            * @param folderId the folder ID
6537            * @param status the status
6538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6539            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6540            * @throws SystemException if a system exception occurred
6541            */
6542            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
6543                    long groupId, long folderId, int status,
6544                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6545                    throws com.liferay.portal.kernel.exception.SystemException {
6546                    return getPersistence()
6547                                       .fetchByG_F_ST_Last(groupId, folderId, status,
6548                            orderByComparator);
6549            }
6550    
6551            /**
6552            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
6553            *
6554            * @param id the primary key of the current journal article
6555            * @param groupId the group ID
6556            * @param folderId the folder ID
6557            * @param status the status
6558            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6559            * @return the previous, current, and next journal article
6560            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6561            * @throws SystemException if a system exception occurred
6562            */
6563            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
6564                    long id, long groupId, long folderId, int status,
6565                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6566                    throws com.liferay.portal.kernel.exception.SystemException,
6567                            com.liferay.portlet.journal.NoSuchArticleException {
6568                    return getPersistence()
6569                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
6570                            orderByComparator);
6571            }
6572    
6573            /**
6574            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6575            *
6576            * @param groupId the group ID
6577            * @param folderId the folder ID
6578            * @param status the status
6579            * @return the matching journal articles that the user has permission to view
6580            * @throws SystemException if a system exception occurred
6581            */
6582            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6583                    long groupId, long folderId, int status)
6584                    throws com.liferay.portal.kernel.exception.SystemException {
6585                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
6586            }
6587    
6588            /**
6589            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6590            *
6591            * <p>
6592            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6593            * </p>
6594            *
6595            * @param groupId the group ID
6596            * @param folderId the folder ID
6597            * @param status the status
6598            * @param start the lower bound of the range of journal articles
6599            * @param end the upper bound of the range of journal articles (not inclusive)
6600            * @return the range of matching journal articles that the user has permission to view
6601            * @throws SystemException if a system exception occurred
6602            */
6603            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6604                    long groupId, long folderId, int status, int start, int end)
6605                    throws com.liferay.portal.kernel.exception.SystemException {
6606                    return getPersistence()
6607                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
6608            }
6609    
6610            /**
6611            * 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;.
6612            *
6613            * <p>
6614            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6615            * </p>
6616            *
6617            * @param groupId the group ID
6618            * @param folderId the folder ID
6619            * @param status the status
6620            * @param start the lower bound of the range of journal articles
6621            * @param end the upper bound of the range of journal articles (not inclusive)
6622            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6623            * @return the ordered range of matching journal articles that the user has permission to view
6624            * @throws SystemException if a system exception occurred
6625            */
6626            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6627                    long groupId, long folderId, int status, int start, int end,
6628                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6629                    throws com.liferay.portal.kernel.exception.SystemException {
6630                    return getPersistence()
6631                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
6632                            orderByComparator);
6633            }
6634    
6635            /**
6636            * 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;.
6637            *
6638            * @param id the primary key of the current journal article
6639            * @param groupId the group ID
6640            * @param folderId the folder ID
6641            * @param status the status
6642            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6643            * @return the previous, current, and next journal article
6644            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6645            * @throws SystemException if a system exception occurred
6646            */
6647            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
6648                    long id, long groupId, long folderId, int status,
6649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6650                    throws com.liferay.portal.kernel.exception.SystemException,
6651                            com.liferay.portlet.journal.NoSuchArticleException {
6652                    return getPersistence()
6653                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
6654                            status, orderByComparator);
6655            }
6656    
6657            /**
6658            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
6659            *
6660            * @param groupId the group ID
6661            * @param folderId the folder ID
6662            * @param statuses the statuses
6663            * @return the matching journal articles that the user has permission to view
6664            * @throws SystemException if a system exception occurred
6665            */
6666            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6667                    long groupId, long folderId, int[] statuses)
6668                    throws com.liferay.portal.kernel.exception.SystemException {
6669                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
6670            }
6671    
6672            /**
6673            * 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;.
6674            *
6675            * <p>
6676            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6677            * </p>
6678            *
6679            * @param groupId the group ID
6680            * @param folderId the folder ID
6681            * @param statuses the statuses
6682            * @param start the lower bound of the range of journal articles
6683            * @param end the upper bound of the range of journal articles (not inclusive)
6684            * @return the range of matching journal articles that the user has permission to view
6685            * @throws SystemException if a system exception occurred
6686            */
6687            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6688                    long groupId, long folderId, int[] statuses, int start, int end)
6689                    throws com.liferay.portal.kernel.exception.SystemException {
6690                    return getPersistence()
6691                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
6692            }
6693    
6694            /**
6695            * 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;.
6696            *
6697            * <p>
6698            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6699            * </p>
6700            *
6701            * @param groupId the group ID
6702            * @param folderId the folder ID
6703            * @param statuses the statuses
6704            * @param start the lower bound of the range of journal articles
6705            * @param end the upper bound of the range of journal articles (not inclusive)
6706            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6707            * @return the ordered range of matching journal articles that the user has permission to view
6708            * @throws SystemException if a system exception occurred
6709            */
6710            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
6711                    long groupId, long folderId, int[] statuses, int start, int end,
6712                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6713                    throws com.liferay.portal.kernel.exception.SystemException {
6714                    return getPersistence()
6715                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
6716                            orderByComparator);
6717            }
6718    
6719            /**
6720            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6721            *
6722            * <p>
6723            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6724            * </p>
6725            *
6726            * @param groupId the group ID
6727            * @param folderId the folder ID
6728            * @param statuses the statuses
6729            * @return the matching journal articles
6730            * @throws SystemException if a system exception occurred
6731            */
6732            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6733                    long groupId, long folderId, int[] statuses)
6734                    throws com.liferay.portal.kernel.exception.SystemException {
6735                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
6736            }
6737    
6738            /**
6739            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6740            *
6741            * <p>
6742            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6743            * </p>
6744            *
6745            * @param groupId the group ID
6746            * @param folderId the folder ID
6747            * @param statuses the statuses
6748            * @param start the lower bound of the range of journal articles
6749            * @param end the upper bound of the range of journal articles (not inclusive)
6750            * @return the range of matching journal articles
6751            * @throws SystemException if a system exception occurred
6752            */
6753            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6754                    long groupId, long folderId, int[] statuses, int start, int end)
6755                    throws com.liferay.portal.kernel.exception.SystemException {
6756                    return getPersistence()
6757                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
6758            }
6759    
6760            /**
6761            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6762            *
6763            * <p>
6764            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6765            * </p>
6766            *
6767            * @param groupId the group ID
6768            * @param folderId the folder ID
6769            * @param statuses the statuses
6770            * @param start the lower bound of the range of journal articles
6771            * @param end the upper bound of the range of journal articles (not inclusive)
6772            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6773            * @return the ordered range of matching journal articles
6774            * @throws SystemException if a system exception occurred
6775            */
6776            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
6777                    long groupId, long folderId, int[] statuses, int start, int end,
6778                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6779                    throws com.liferay.portal.kernel.exception.SystemException {
6780                    return getPersistence()
6781                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
6782                            orderByComparator);
6783            }
6784    
6785            /**
6786            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
6787            *
6788            * @param groupId the group ID
6789            * @param folderId the folder ID
6790            * @param status the status
6791            * @throws SystemException if a system exception occurred
6792            */
6793            public static void removeByG_F_ST(long groupId, long folderId, int status)
6794                    throws com.liferay.portal.kernel.exception.SystemException {
6795                    getPersistence().removeByG_F_ST(groupId, folderId, status);
6796            }
6797    
6798            /**
6799            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
6800            *
6801            * @param groupId the group ID
6802            * @param folderId the folder ID
6803            * @param status the status
6804            * @return the number of matching journal articles
6805            * @throws SystemException if a system exception occurred
6806            */
6807            public static int countByG_F_ST(long groupId, long folderId, int status)
6808                    throws com.liferay.portal.kernel.exception.SystemException {
6809                    return getPersistence().countByG_F_ST(groupId, folderId, status);
6810            }
6811    
6812            /**
6813            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
6814            *
6815            * @param groupId the group ID
6816            * @param folderId the folder ID
6817            * @param statuses the statuses
6818            * @return the number of matching journal articles
6819            * @throws SystemException if a system exception occurred
6820            */
6821            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
6822                    throws com.liferay.portal.kernel.exception.SystemException {
6823                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
6824            }
6825    
6826            /**
6827            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
6828            *
6829            * @param groupId the group ID
6830            * @param folderId the folder ID
6831            * @param status the status
6832            * @return the number of matching journal articles that the user has permission to view
6833            * @throws SystemException if a system exception occurred
6834            */
6835            public static int filterCountByG_F_ST(long groupId, long folderId,
6836                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6837                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
6838            }
6839    
6840            /**
6841            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
6842            *
6843            * @param groupId the group ID
6844            * @param folderId the folder ID
6845            * @param statuses the statuses
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_F_ST(long groupId, long folderId,
6850                    int[] statuses)
6851                    throws com.liferay.portal.kernel.exception.SystemException {
6852                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
6853            }
6854    
6855            /**
6856            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6857            *
6858            * @param groupId the group ID
6859            * @param classNameId the class name ID
6860            * @param classPK the class p k
6861            * @return the matching journal articles
6862            * @throws SystemException if a system exception occurred
6863            */
6864            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6865                    long groupId, long classNameId, long classPK)
6866                    throws com.liferay.portal.kernel.exception.SystemException {
6867                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
6868            }
6869    
6870            /**
6871            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6872            *
6873            * <p>
6874            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6875            * </p>
6876            *
6877            * @param groupId the group ID
6878            * @param classNameId the class name ID
6879            * @param classPK the class p k
6880            * @param start the lower bound of the range of journal articles
6881            * @param end the upper bound of the range of journal articles (not inclusive)
6882            * @return the range of matching journal articles
6883            * @throws SystemException if a system exception occurred
6884            */
6885            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6886                    long groupId, long classNameId, long classPK, int start, int end)
6887                    throws com.liferay.portal.kernel.exception.SystemException {
6888                    return getPersistence()
6889                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
6890            }
6891    
6892            /**
6893            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6894            *
6895            * <p>
6896            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6897            * </p>
6898            *
6899            * @param groupId the group ID
6900            * @param classNameId the class name ID
6901            * @param classPK the class p k
6902            * @param start the lower bound of the range of journal articles
6903            * @param end the upper bound of the range of journal articles (not inclusive)
6904            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6905            * @return the ordered range of matching journal articles
6906            * @throws SystemException if a system exception occurred
6907            */
6908            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
6909                    long groupId, long classNameId, long classPK, int start, int end,
6910                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6911                    throws com.liferay.portal.kernel.exception.SystemException {
6912                    return getPersistence()
6913                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
6914                            orderByComparator);
6915            }
6916    
6917            /**
6918            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6919            *
6920            * @param groupId the group ID
6921            * @param classNameId the class name ID
6922            * @param classPK the class p k
6923            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6924            * @return the first matching journal article
6925            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6926            * @throws SystemException if a system exception occurred
6927            */
6928            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
6929                    long groupId, long classNameId, long classPK,
6930                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6931                    throws com.liferay.portal.kernel.exception.SystemException,
6932                            com.liferay.portlet.journal.NoSuchArticleException {
6933                    return getPersistence()
6934                                       .findByG_C_C_First(groupId, classNameId, classPK,
6935                            orderByComparator);
6936            }
6937    
6938            /**
6939            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6940            *
6941            * @param groupId the group ID
6942            * @param classNameId the class name ID
6943            * @param classPK the class p k
6944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6945            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6946            * @throws SystemException if a system exception occurred
6947            */
6948            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
6949                    long groupId, long classNameId, long classPK,
6950                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6951                    throws com.liferay.portal.kernel.exception.SystemException {
6952                    return getPersistence()
6953                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
6954                            orderByComparator);
6955            }
6956    
6957            /**
6958            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6959            *
6960            * @param groupId the group ID
6961            * @param classNameId the class name ID
6962            * @param classPK the class p k
6963            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6964            * @return the last matching journal article
6965            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6966            * @throws SystemException if a system exception occurred
6967            */
6968            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
6969                    long groupId, long classNameId, long classPK,
6970                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6971                    throws com.liferay.portal.kernel.exception.SystemException,
6972                            com.liferay.portlet.journal.NoSuchArticleException {
6973                    return getPersistence()
6974                                       .findByG_C_C_Last(groupId, classNameId, classPK,
6975                            orderByComparator);
6976            }
6977    
6978            /**
6979            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6980            *
6981            * @param groupId the group ID
6982            * @param classNameId the class name ID
6983            * @param classPK the class p k
6984            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6985            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6986            * @throws SystemException if a system exception occurred
6987            */
6988            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
6989                    long groupId, long classNameId, long classPK,
6990                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6991                    throws com.liferay.portal.kernel.exception.SystemException {
6992                    return getPersistence()
6993                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
6994                            orderByComparator);
6995            }
6996    
6997            /**
6998            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
6999            *
7000            * @param id the primary key of the current journal article
7001            * @param groupId the group ID
7002            * @param classNameId the class name ID
7003            * @param classPK the class p k
7004            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7005            * @return the previous, current, and next journal article
7006            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7007            * @throws SystemException if a system exception occurred
7008            */
7009            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
7010                    long id, long groupId, long classNameId, long classPK,
7011                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7012                    throws com.liferay.portal.kernel.exception.SystemException,
7013                            com.liferay.portlet.journal.NoSuchArticleException {
7014                    return getPersistence()
7015                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
7016                            orderByComparator);
7017            }
7018    
7019            /**
7020            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
7021            *
7022            * @param groupId the group ID
7023            * @param classNameId the class name ID
7024            * @param classPK the class p k
7025            * @return the matching journal articles that the user has permission to view
7026            * @throws SystemException if a system exception occurred
7027            */
7028            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
7029                    long groupId, long classNameId, long classPK)
7030                    throws com.liferay.portal.kernel.exception.SystemException {
7031                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
7032            }
7033    
7034            /**
7035            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
7036            *
7037            * <p>
7038            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7039            * </p>
7040            *
7041            * @param groupId the group ID
7042            * @param classNameId the class name ID
7043            * @param classPK the class p k
7044            * @param start the lower bound of the range of journal articles
7045            * @param end the upper bound of the range of journal articles (not inclusive)
7046            * @return the range of matching journal articles that the user has permission to view
7047            * @throws SystemException if a system exception occurred
7048            */
7049            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
7050                    long groupId, long classNameId, long classPK, int start, int end)
7051                    throws com.liferay.portal.kernel.exception.SystemException {
7052                    return getPersistence()
7053                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
7054            }
7055    
7056            /**
7057            * 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;.
7058            *
7059            * <p>
7060            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7061            * </p>
7062            *
7063            * @param groupId the group ID
7064            * @param classNameId the class name ID
7065            * @param classPK the class p k
7066            * @param start the lower bound of the range of journal articles
7067            * @param end the upper bound of the range of journal articles (not inclusive)
7068            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7069            * @return the ordered range of matching journal articles that the user has permission to view
7070            * @throws SystemException if a system exception occurred
7071            */
7072            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
7073                    long groupId, long classNameId, long classPK, int start, int end,
7074                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7075                    throws com.liferay.portal.kernel.exception.SystemException {
7076                    return getPersistence()
7077                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
7078                            end, orderByComparator);
7079            }
7080    
7081            /**
7082            * 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;.
7083            *
7084            * @param id the primary key of the current journal article
7085            * @param groupId the group ID
7086            * @param classNameId the class name ID
7087            * @param classPK the class p k
7088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7089            * @return the previous, current, and next journal article
7090            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7091            * @throws SystemException if a system exception occurred
7092            */
7093            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
7094                    long id, long groupId, long classNameId, long classPK,
7095                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7096                    throws com.liferay.portal.kernel.exception.SystemException,
7097                            com.liferay.portlet.journal.NoSuchArticleException {
7098                    return getPersistence()
7099                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
7100                            classPK, orderByComparator);
7101            }
7102    
7103            /**
7104            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
7105            *
7106            * @param groupId the group ID
7107            * @param classNameId the class name ID
7108            * @param classPK the class p k
7109            * @throws SystemException if a system exception occurred
7110            */
7111            public static void removeByG_C_C(long groupId, long classNameId,
7112                    long classPK)
7113                    throws com.liferay.portal.kernel.exception.SystemException {
7114                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
7115            }
7116    
7117            /**
7118            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
7119            *
7120            * @param groupId the group ID
7121            * @param classNameId the class name ID
7122            * @param classPK the class p k
7123            * @return the number of matching journal articles
7124            * @throws SystemException if a system exception occurred
7125            */
7126            public static int countByG_C_C(long groupId, long classNameId, long classPK)
7127                    throws com.liferay.portal.kernel.exception.SystemException {
7128                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
7129            }
7130    
7131            /**
7132            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
7133            *
7134            * @param groupId the group ID
7135            * @param classNameId the class name ID
7136            * @param classPK the class p k
7137            * @return the number of matching journal articles that the user has permission to view
7138            * @throws SystemException if a system exception occurred
7139            */
7140            public static int filterCountByG_C_C(long groupId, long classNameId,
7141                    long classPK)
7142                    throws com.liferay.portal.kernel.exception.SystemException {
7143                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
7144            }
7145    
7146            /**
7147            * 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.
7148            *
7149            * @param groupId the group ID
7150            * @param classNameId the class name ID
7151            * @param structureId the structure ID
7152            * @return the matching journal article
7153            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7154            * @throws SystemException if a system exception occurred
7155            */
7156            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
7157                    long groupId, long classNameId, java.lang.String structureId)
7158                    throws com.liferay.portal.kernel.exception.SystemException,
7159                            com.liferay.portlet.journal.NoSuchArticleException {
7160                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
7161            }
7162    
7163            /**
7164            * 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.
7165            *
7166            * @param groupId the group ID
7167            * @param classNameId the class name ID
7168            * @param structureId the structure ID
7169            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7170            * @throws SystemException if a system exception occurred
7171            */
7172            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
7173                    long groupId, long classNameId, java.lang.String structureId)
7174                    throws com.liferay.portal.kernel.exception.SystemException {
7175                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
7176            }
7177    
7178            /**
7179            * 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.
7180            *
7181            * @param groupId the group ID
7182            * @param classNameId the class name ID
7183            * @param structureId the structure ID
7184            * @param retrieveFromCache whether to use the finder cache
7185            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7186            * @throws SystemException if a system exception occurred
7187            */
7188            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
7189                    long groupId, long classNameId, java.lang.String structureId,
7190                    boolean retrieveFromCache)
7191                    throws com.liferay.portal.kernel.exception.SystemException {
7192                    return getPersistence()
7193                                       .fetchByG_C_S(groupId, classNameId, structureId,
7194                            retrieveFromCache);
7195            }
7196    
7197            /**
7198            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
7199            *
7200            * @param groupId the group ID
7201            * @param classNameId the class name ID
7202            * @param structureId the structure ID
7203            * @return the journal article that was removed
7204            * @throws SystemException if a system exception occurred
7205            */
7206            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
7207                    long groupId, long classNameId, java.lang.String structureId)
7208                    throws com.liferay.portal.kernel.exception.SystemException,
7209                            com.liferay.portlet.journal.NoSuchArticleException {
7210                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
7211            }
7212    
7213            /**
7214            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
7215            *
7216            * @param groupId the group ID
7217            * @param classNameId the class name ID
7218            * @param structureId the structure ID
7219            * @return the number of matching journal articles
7220            * @throws SystemException if a system exception occurred
7221            */
7222            public static int countByG_C_S(long groupId, long classNameId,
7223                    java.lang.String structureId)
7224                    throws com.liferay.portal.kernel.exception.SystemException {
7225                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
7226            }
7227    
7228            /**
7229            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7230            *
7231            * @param groupId the group ID
7232            * @param classNameId the class name ID
7233            * @param templateId the template ID
7234            * @return the matching journal articles
7235            * @throws SystemException if a system exception occurred
7236            */
7237            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
7238                    long groupId, long classNameId, java.lang.String templateId)
7239                    throws com.liferay.portal.kernel.exception.SystemException {
7240                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
7241            }
7242    
7243            /**
7244            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7245            *
7246            * <p>
7247            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7248            * </p>
7249            *
7250            * @param groupId the group ID
7251            * @param classNameId the class name ID
7252            * @param templateId the template ID
7253            * @param start the lower bound of the range of journal articles
7254            * @param end the upper bound of the range of journal articles (not inclusive)
7255            * @return the range of matching journal articles
7256            * @throws SystemException if a system exception occurred
7257            */
7258            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
7259                    long groupId, long classNameId, java.lang.String templateId, int start,
7260                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7261                    return getPersistence()
7262                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
7263            }
7264    
7265            /**
7266            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7267            *
7268            * <p>
7269            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7270            * </p>
7271            *
7272            * @param groupId the group ID
7273            * @param classNameId the class name ID
7274            * @param templateId the template ID
7275            * @param start the lower bound of the range of journal articles
7276            * @param end the upper bound of the range of journal articles (not inclusive)
7277            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7278            * @return the ordered range of matching journal articles
7279            * @throws SystemException if a system exception occurred
7280            */
7281            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
7282                    long groupId, long classNameId, java.lang.String templateId, int start,
7283                    int end,
7284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7285                    throws com.liferay.portal.kernel.exception.SystemException {
7286                    return getPersistence()
7287                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
7288                            orderByComparator);
7289            }
7290    
7291            /**
7292            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7293            *
7294            * @param groupId the group ID
7295            * @param classNameId the class name ID
7296            * @param templateId the template ID
7297            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7298            * @return the first matching journal article
7299            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7300            * @throws SystemException if a system exception occurred
7301            */
7302            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
7303                    long groupId, long classNameId, java.lang.String templateId,
7304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7305                    throws com.liferay.portal.kernel.exception.SystemException,
7306                            com.liferay.portlet.journal.NoSuchArticleException {
7307                    return getPersistence()
7308                                       .findByG_C_T_First(groupId, classNameId, templateId,
7309                            orderByComparator);
7310            }
7311    
7312            /**
7313            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7314            *
7315            * @param groupId the group ID
7316            * @param classNameId the class name ID
7317            * @param templateId the template ID
7318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7319            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7320            * @throws SystemException if a system exception occurred
7321            */
7322            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
7323                    long groupId, long classNameId, java.lang.String templateId,
7324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7325                    throws com.liferay.portal.kernel.exception.SystemException {
7326                    return getPersistence()
7327                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
7328                            orderByComparator);
7329            }
7330    
7331            /**
7332            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7333            *
7334            * @param groupId the group ID
7335            * @param classNameId the class name ID
7336            * @param templateId the template ID
7337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7338            * @return the last matching journal article
7339            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7340            * @throws SystemException if a system exception occurred
7341            */
7342            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
7343                    long groupId, long classNameId, java.lang.String templateId,
7344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7345                    throws com.liferay.portal.kernel.exception.SystemException,
7346                            com.liferay.portlet.journal.NoSuchArticleException {
7347                    return getPersistence()
7348                                       .findByG_C_T_Last(groupId, classNameId, templateId,
7349                            orderByComparator);
7350            }
7351    
7352            /**
7353            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7354            *
7355            * @param groupId the group ID
7356            * @param classNameId the class name ID
7357            * @param templateId the template ID
7358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7359            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7360            * @throws SystemException if a system exception occurred
7361            */
7362            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
7363                    long groupId, long classNameId, java.lang.String templateId,
7364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7365                    throws com.liferay.portal.kernel.exception.SystemException {
7366                    return getPersistence()
7367                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
7368                            orderByComparator);
7369            }
7370    
7371            /**
7372            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7373            *
7374            * @param id the primary key of the current journal article
7375            * @param groupId the group ID
7376            * @param classNameId the class name ID
7377            * @param templateId the template ID
7378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7379            * @return the previous, current, and next journal article
7380            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7381            * @throws SystemException if a system exception occurred
7382            */
7383            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
7384                    long id, long groupId, long classNameId, java.lang.String templateId,
7385                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7386                    throws com.liferay.portal.kernel.exception.SystemException,
7387                            com.liferay.portlet.journal.NoSuchArticleException {
7388                    return getPersistence()
7389                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
7390                            templateId, orderByComparator);
7391            }
7392    
7393            /**
7394            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7395            *
7396            * @param groupId the group ID
7397            * @param classNameId the class name ID
7398            * @param templateId the template ID
7399            * @return the matching journal articles that the user has permission to view
7400            * @throws SystemException if a system exception occurred
7401            */
7402            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
7403                    long groupId, long classNameId, java.lang.String templateId)
7404                    throws com.liferay.portal.kernel.exception.SystemException {
7405                    return getPersistence()
7406                                       .filterFindByG_C_T(groupId, classNameId, templateId);
7407            }
7408    
7409            /**
7410            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7411            *
7412            * <p>
7413            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7414            * </p>
7415            *
7416            * @param groupId the group ID
7417            * @param classNameId the class name ID
7418            * @param templateId the template ID
7419            * @param start the lower bound of the range of journal articles
7420            * @param end the upper bound of the range of journal articles (not inclusive)
7421            * @return the range of matching journal articles that the user has permission to view
7422            * @throws SystemException if a system exception occurred
7423            */
7424            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
7425                    long groupId, long classNameId, java.lang.String templateId, int start,
7426                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7427                    return getPersistence()
7428                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
7429                            end);
7430            }
7431    
7432            /**
7433            * 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;.
7434            *
7435            * <p>
7436            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7437            * </p>
7438            *
7439            * @param groupId the group ID
7440            * @param classNameId the class name ID
7441            * @param templateId the template ID
7442            * @param start the lower bound of the range of journal articles
7443            * @param end the upper bound of the range of journal articles (not inclusive)
7444            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7445            * @return the ordered range of matching journal articles that the user has permission to view
7446            * @throws SystemException if a system exception occurred
7447            */
7448            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
7449                    long groupId, long classNameId, java.lang.String templateId, int start,
7450                    int end,
7451                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7452                    throws com.liferay.portal.kernel.exception.SystemException {
7453                    return getPersistence()
7454                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
7455                            end, orderByComparator);
7456            }
7457    
7458            /**
7459            * 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;.
7460            *
7461            * @param id the primary key of the current journal article
7462            * @param groupId the group ID
7463            * @param classNameId the class name ID
7464            * @param templateId the template ID
7465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7466            * @return the previous, current, and next journal article
7467            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7468            * @throws SystemException if a system exception occurred
7469            */
7470            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
7471                    long id, long groupId, long classNameId, java.lang.String templateId,
7472                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7473                    throws com.liferay.portal.kernel.exception.SystemException,
7474                            com.liferay.portlet.journal.NoSuchArticleException {
7475                    return getPersistence()
7476                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
7477                            templateId, orderByComparator);
7478            }
7479    
7480            /**
7481            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
7482            *
7483            * @param groupId the group ID
7484            * @param classNameId the class name ID
7485            * @param templateId the template ID
7486            * @throws SystemException if a system exception occurred
7487            */
7488            public static void removeByG_C_T(long groupId, long classNameId,
7489                    java.lang.String templateId)
7490                    throws com.liferay.portal.kernel.exception.SystemException {
7491                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
7492            }
7493    
7494            /**
7495            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7496            *
7497            * @param groupId the group ID
7498            * @param classNameId the class name ID
7499            * @param templateId the template ID
7500            * @return the number of matching journal articles
7501            * @throws SystemException if a system exception occurred
7502            */
7503            public static int countByG_C_T(long groupId, long classNameId,
7504                    java.lang.String templateId)
7505                    throws com.liferay.portal.kernel.exception.SystemException {
7506                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
7507            }
7508    
7509            /**
7510            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
7511            *
7512            * @param groupId the group ID
7513            * @param classNameId the class name ID
7514            * @param templateId the template ID
7515            * @return the number of matching journal articles that the user has permission to view
7516            * @throws SystemException if a system exception occurred
7517            */
7518            public static int filterCountByG_C_T(long groupId, long classNameId,
7519                    java.lang.String templateId)
7520                    throws com.liferay.portal.kernel.exception.SystemException {
7521                    return getPersistence()
7522                                       .filterCountByG_C_T(groupId, classNameId, templateId);
7523            }
7524    
7525            /**
7526            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7527            *
7528            * @param groupId the group ID
7529            * @param classNameId the class name ID
7530            * @param layoutUuid the layout uuid
7531            * @return the matching journal articles
7532            * @throws SystemException if a system exception occurred
7533            */
7534            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
7535                    long groupId, long classNameId, java.lang.String layoutUuid)
7536                    throws com.liferay.portal.kernel.exception.SystemException {
7537                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
7538            }
7539    
7540            /**
7541            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7542            *
7543            * <p>
7544            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7545            * </p>
7546            *
7547            * @param groupId the group ID
7548            * @param classNameId the class name ID
7549            * @param layoutUuid the layout uuid
7550            * @param start the lower bound of the range of journal articles
7551            * @param end the upper bound of the range of journal articles (not inclusive)
7552            * @return the range of matching journal articles
7553            * @throws SystemException if a system exception occurred
7554            */
7555            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
7556                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7557                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7558                    return getPersistence()
7559                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
7560            }
7561    
7562            /**
7563            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7564            *
7565            * <p>
7566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7567            * </p>
7568            *
7569            * @param groupId the group ID
7570            * @param classNameId the class name ID
7571            * @param layoutUuid the layout uuid
7572            * @param start the lower bound of the range of journal articles
7573            * @param end the upper bound of the range of journal articles (not inclusive)
7574            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7575            * @return the ordered range of matching journal articles
7576            * @throws SystemException if a system exception occurred
7577            */
7578            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
7579                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7580                    int end,
7581                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7582                    throws com.liferay.portal.kernel.exception.SystemException {
7583                    return getPersistence()
7584                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
7585                            orderByComparator);
7586            }
7587    
7588            /**
7589            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7590            *
7591            * @param groupId the group ID
7592            * @param classNameId the class name ID
7593            * @param layoutUuid the layout uuid
7594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7595            * @return the first matching journal article
7596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7597            * @throws SystemException if a system exception occurred
7598            */
7599            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
7600                    long groupId, long classNameId, java.lang.String layoutUuid,
7601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7602                    throws com.liferay.portal.kernel.exception.SystemException,
7603                            com.liferay.portlet.journal.NoSuchArticleException {
7604                    return getPersistence()
7605                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
7606                            orderByComparator);
7607            }
7608    
7609            /**
7610            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7611            *
7612            * @param groupId the group ID
7613            * @param classNameId the class name ID
7614            * @param layoutUuid the layout uuid
7615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7616            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7617            * @throws SystemException if a system exception occurred
7618            */
7619            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
7620                    long groupId, long classNameId, java.lang.String layoutUuid,
7621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7622                    throws com.liferay.portal.kernel.exception.SystemException {
7623                    return getPersistence()
7624                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
7625                            orderByComparator);
7626            }
7627    
7628            /**
7629            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7630            *
7631            * @param groupId the group ID
7632            * @param classNameId the class name ID
7633            * @param layoutUuid the layout uuid
7634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7635            * @return the last matching journal article
7636            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7637            * @throws SystemException if a system exception occurred
7638            */
7639            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
7640                    long groupId, long classNameId, java.lang.String layoutUuid,
7641                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7642                    throws com.liferay.portal.kernel.exception.SystemException,
7643                            com.liferay.portlet.journal.NoSuchArticleException {
7644                    return getPersistence()
7645                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
7646                            orderByComparator);
7647            }
7648    
7649            /**
7650            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7651            *
7652            * @param groupId the group ID
7653            * @param classNameId the class name ID
7654            * @param layoutUuid the layout uuid
7655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7656            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7657            * @throws SystemException if a system exception occurred
7658            */
7659            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
7660                    long groupId, long classNameId, java.lang.String layoutUuid,
7661                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7662                    throws com.liferay.portal.kernel.exception.SystemException {
7663                    return getPersistence()
7664                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
7665                            orderByComparator);
7666            }
7667    
7668            /**
7669            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7670            *
7671            * @param id the primary key of the current journal article
7672            * @param groupId the group ID
7673            * @param classNameId the class name ID
7674            * @param layoutUuid the layout uuid
7675            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7676            * @return the previous, current, and next journal article
7677            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7678            * @throws SystemException if a system exception occurred
7679            */
7680            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
7681                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
7682                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7683                    throws com.liferay.portal.kernel.exception.SystemException,
7684                            com.liferay.portlet.journal.NoSuchArticleException {
7685                    return getPersistence()
7686                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
7687                            layoutUuid, orderByComparator);
7688            }
7689    
7690            /**
7691            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7692            *
7693            * @param groupId the group ID
7694            * @param classNameId the class name ID
7695            * @param layoutUuid the layout uuid
7696            * @return the matching journal articles that the user has permission to view
7697            * @throws SystemException if a system exception occurred
7698            */
7699            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7700                    long groupId, long classNameId, java.lang.String layoutUuid)
7701                    throws com.liferay.portal.kernel.exception.SystemException {
7702                    return getPersistence()
7703                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
7704            }
7705    
7706            /**
7707            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7708            *
7709            * <p>
7710            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7711            * </p>
7712            *
7713            * @param groupId the group ID
7714            * @param classNameId the class name ID
7715            * @param layoutUuid the layout uuid
7716            * @param start the lower bound of the range of journal articles
7717            * @param end the upper bound of the range of journal articles (not inclusive)
7718            * @return the range of matching journal articles that the user has permission to view
7719            * @throws SystemException if a system exception occurred
7720            */
7721            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7722                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7723                    int end) throws com.liferay.portal.kernel.exception.SystemException {
7724                    return getPersistence()
7725                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
7726                            end);
7727            }
7728    
7729            /**
7730            * 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;.
7731            *
7732            * <p>
7733            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7734            * </p>
7735            *
7736            * @param groupId the group ID
7737            * @param classNameId the class name ID
7738            * @param layoutUuid the layout uuid
7739            * @param start the lower bound of the range of journal articles
7740            * @param end the upper bound of the range of journal articles (not inclusive)
7741            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7742            * @return the ordered range of matching journal articles that the user has permission to view
7743            * @throws SystemException if a system exception occurred
7744            */
7745            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
7746                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
7747                    int end,
7748                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7749                    throws com.liferay.portal.kernel.exception.SystemException {
7750                    return getPersistence()
7751                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
7752                            end, orderByComparator);
7753            }
7754    
7755            /**
7756            * 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;.
7757            *
7758            * @param id the primary key of the current journal article
7759            * @param groupId the group ID
7760            * @param classNameId the class name ID
7761            * @param layoutUuid the layout uuid
7762            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7763            * @return the previous, current, and next journal article
7764            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7765            * @throws SystemException if a system exception occurred
7766            */
7767            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
7768                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
7769                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7770                    throws com.liferay.portal.kernel.exception.SystemException,
7771                            com.liferay.portlet.journal.NoSuchArticleException {
7772                    return getPersistence()
7773                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
7774                            layoutUuid, orderByComparator);
7775            }
7776    
7777            /**
7778            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
7779            *
7780            * @param groupId the group ID
7781            * @param classNameId the class name ID
7782            * @param layoutUuid the layout uuid
7783            * @throws SystemException if a system exception occurred
7784            */
7785            public static void removeByG_C_L(long groupId, long classNameId,
7786                    java.lang.String layoutUuid)
7787                    throws com.liferay.portal.kernel.exception.SystemException {
7788                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
7789            }
7790    
7791            /**
7792            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7793            *
7794            * @param groupId the group ID
7795            * @param classNameId the class name ID
7796            * @param layoutUuid the layout uuid
7797            * @return the number of matching journal articles
7798            * @throws SystemException if a system exception occurred
7799            */
7800            public static int countByG_C_L(long groupId, long classNameId,
7801                    java.lang.String layoutUuid)
7802                    throws com.liferay.portal.kernel.exception.SystemException {
7803                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
7804            }
7805    
7806            /**
7807            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
7808            *
7809            * @param groupId the group ID
7810            * @param classNameId the class name ID
7811            * @param layoutUuid the layout uuid
7812            * @return the number of matching journal articles that the user has permission to view
7813            * @throws SystemException if a system exception occurred
7814            */
7815            public static int filterCountByG_C_L(long groupId, long classNameId,
7816                    java.lang.String layoutUuid)
7817                    throws com.liferay.portal.kernel.exception.SystemException {
7818                    return getPersistence()
7819                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
7820            }
7821    
7822            /**
7823            * 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.
7824            *
7825            * @param groupId the group ID
7826            * @param articleId the article ID
7827            * @param version the version
7828            * @return the matching journal article
7829            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7830            * @throws SystemException if a system exception occurred
7831            */
7832            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
7833                    long groupId, java.lang.String articleId, double version)
7834                    throws com.liferay.portal.kernel.exception.SystemException,
7835                            com.liferay.portlet.journal.NoSuchArticleException {
7836                    return getPersistence().findByG_A_V(groupId, articleId, version);
7837            }
7838    
7839            /**
7840            * 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.
7841            *
7842            * @param groupId the group ID
7843            * @param articleId the article ID
7844            * @param version the version
7845            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7846            * @throws SystemException if a system exception occurred
7847            */
7848            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7849                    long groupId, java.lang.String articleId, double version)
7850                    throws com.liferay.portal.kernel.exception.SystemException {
7851                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
7852            }
7853    
7854            /**
7855            * 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.
7856            *
7857            * @param groupId the group ID
7858            * @param articleId the article ID
7859            * @param version the version
7860            * @param retrieveFromCache whether to use the finder cache
7861            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
7862            * @throws SystemException if a system exception occurred
7863            */
7864            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
7865                    long groupId, java.lang.String articleId, double version,
7866                    boolean retrieveFromCache)
7867                    throws com.liferay.portal.kernel.exception.SystemException {
7868                    return getPersistence()
7869                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
7870            }
7871    
7872            /**
7873            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
7874            *
7875            * @param groupId the group ID
7876            * @param articleId the article ID
7877            * @param version the version
7878            * @return the journal article that was removed
7879            * @throws SystemException if a system exception occurred
7880            */
7881            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
7882                    long groupId, java.lang.String articleId, double version)
7883                    throws com.liferay.portal.kernel.exception.SystemException,
7884                            com.liferay.portlet.journal.NoSuchArticleException {
7885                    return getPersistence().removeByG_A_V(groupId, articleId, version);
7886            }
7887    
7888            /**
7889            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
7890            *
7891            * @param groupId the group ID
7892            * @param articleId the article ID
7893            * @param version the version
7894            * @return the number of matching journal articles
7895            * @throws SystemException if a system exception occurred
7896            */
7897            public static int countByG_A_V(long groupId, java.lang.String articleId,
7898                    double version)
7899                    throws com.liferay.portal.kernel.exception.SystemException {
7900                    return getPersistence().countByG_A_V(groupId, articleId, version);
7901            }
7902    
7903            /**
7904            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7905            *
7906            * @param groupId the group ID
7907            * @param articleId the article ID
7908            * @param status the status
7909            * @return the matching journal articles
7910            * @throws SystemException if a system exception occurred
7911            */
7912            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7913                    long groupId, java.lang.String articleId, int status)
7914                    throws com.liferay.portal.kernel.exception.SystemException {
7915                    return getPersistence().findByG_A_ST(groupId, articleId, status);
7916            }
7917    
7918            /**
7919            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7920            *
7921            * <p>
7922            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7923            * </p>
7924            *
7925            * @param groupId the group ID
7926            * @param articleId the article ID
7927            * @param status the status
7928            * @param start the lower bound of the range of journal articles
7929            * @param end the upper bound of the range of journal articles (not inclusive)
7930            * @return the range of matching journal articles
7931            * @throws SystemException if a system exception occurred
7932            */
7933            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7934                    long groupId, java.lang.String articleId, int status, int start, int end)
7935                    throws com.liferay.portal.kernel.exception.SystemException {
7936                    return getPersistence()
7937                                       .findByG_A_ST(groupId, articleId, status, start, end);
7938            }
7939    
7940            /**
7941            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7942            *
7943            * <p>
7944            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7945            * </p>
7946            *
7947            * @param groupId the group ID
7948            * @param articleId the article ID
7949            * @param status the status
7950            * @param start the lower bound of the range of journal articles
7951            * @param end the upper bound of the range of journal articles (not inclusive)
7952            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7953            * @return the ordered range of matching journal articles
7954            * @throws SystemException if a system exception occurred
7955            */
7956            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7957                    long groupId, java.lang.String articleId, int status, int start,
7958                    int end,
7959                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7960                    throws com.liferay.portal.kernel.exception.SystemException {
7961                    return getPersistence()
7962                                       .findByG_A_ST(groupId, articleId, status, start, end,
7963                            orderByComparator);
7964            }
7965    
7966            /**
7967            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7968            *
7969            * @param groupId the group ID
7970            * @param articleId the article ID
7971            * @param status the status
7972            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7973            * @return the first matching journal article
7974            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7975            * @throws SystemException if a system exception occurred
7976            */
7977            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
7978                    long groupId, java.lang.String articleId, int status,
7979                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7980                    throws com.liferay.portal.kernel.exception.SystemException,
7981                            com.liferay.portlet.journal.NoSuchArticleException {
7982                    return getPersistence()
7983                                       .findByG_A_ST_First(groupId, articleId, status,
7984                            orderByComparator);
7985            }
7986    
7987            /**
7988            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
7989            *
7990            * @param groupId the group ID
7991            * @param articleId the article ID
7992            * @param status the status
7993            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7994            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7995            * @throws SystemException if a system exception occurred
7996            */
7997            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
7998                    long groupId, java.lang.String articleId, int status,
7999                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8000                    throws com.liferay.portal.kernel.exception.SystemException {
8001                    return getPersistence()
8002                                       .fetchByG_A_ST_First(groupId, articleId, status,
8003                            orderByComparator);
8004            }
8005    
8006            /**
8007            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
8008            *
8009            * @param groupId the group ID
8010            * @param articleId the article ID
8011            * @param status the status
8012            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8013            * @return the last matching journal article
8014            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8015            * @throws SystemException if a system exception occurred
8016            */
8017            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
8018                    long groupId, java.lang.String articleId, int status,
8019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8020                    throws com.liferay.portal.kernel.exception.SystemException,
8021                            com.liferay.portlet.journal.NoSuchArticleException {
8022                    return getPersistence()
8023                                       .findByG_A_ST_Last(groupId, articleId, status,
8024                            orderByComparator);
8025            }
8026    
8027            /**
8028            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
8029            *
8030            * @param groupId the group ID
8031            * @param articleId the article ID
8032            * @param status the status
8033            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8034            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
8035            * @throws SystemException if a system exception occurred
8036            */
8037            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
8038                    long groupId, java.lang.String articleId, int status,
8039                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8040                    throws com.liferay.portal.kernel.exception.SystemException {
8041                    return getPersistence()
8042                                       .fetchByG_A_ST_Last(groupId, articleId, status,
8043                            orderByComparator);
8044            }
8045    
8046            /**
8047            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
8048            *
8049            * @param id the primary key of the current journal article
8050            * @param groupId the group ID
8051            * @param articleId the article ID
8052            * @param status the status
8053            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8054            * @return the previous, current, and next journal article
8055            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8056            * @throws SystemException if a system exception occurred
8057            */
8058            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
8059                    long id, long groupId, java.lang.String articleId, int status,
8060                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8061                    throws com.liferay.portal.kernel.exception.SystemException,
8062                            com.liferay.portlet.journal.NoSuchArticleException {
8063                    return getPersistence()
8064                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
8065                            orderByComparator);
8066            }
8067    
8068            /**
8069            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
8070            *
8071            * @param groupId the group ID
8072            * @param articleId the article ID
8073            * @param status the status
8074            * @return the matching journal articles that the user has permission to view
8075            * @throws SystemException if a system exception occurred
8076            */
8077            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
8078                    long groupId, java.lang.String articleId, int status)
8079                    throws com.liferay.portal.kernel.exception.SystemException {
8080                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
8081            }
8082    
8083            /**
8084            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
8085            *
8086            * <p>
8087            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8088            * </p>
8089            *
8090            * @param groupId the group ID
8091            * @param articleId the article ID
8092            * @param status the status
8093            * @param start the lower bound of the range of journal articles
8094            * @param end the upper bound of the range of journal articles (not inclusive)
8095            * @return the range of matching journal articles that the user has permission to view
8096            * @throws SystemException if a system exception occurred
8097            */
8098            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
8099                    long groupId, java.lang.String articleId, int status, int start, int end)
8100                    throws com.liferay.portal.kernel.exception.SystemException {
8101                    return getPersistence()
8102                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
8103            }
8104    
8105            /**
8106            * 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;.
8107            *
8108            * <p>
8109            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8110            * </p>
8111            *
8112            * @param groupId the group ID
8113            * @param articleId the article ID
8114            * @param status the status
8115            * @param start the lower bound of the range of journal articles
8116            * @param end the upper bound of the range of journal articles (not inclusive)
8117            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8118            * @return the ordered range of matching journal articles that the user has permission to view
8119            * @throws SystemException if a system exception occurred
8120            */
8121            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
8122                    long groupId, java.lang.String articleId, int status, int start,
8123                    int end,
8124                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8125                    throws com.liferay.portal.kernel.exception.SystemException {
8126                    return getPersistence()
8127                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
8128                            orderByComparator);
8129            }
8130    
8131            /**
8132            * 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;.
8133            *
8134            * @param id the primary key of the current journal article
8135            * @param groupId the group ID
8136            * @param articleId the article ID
8137            * @param status the status
8138            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8139            * @return the previous, current, and next journal article
8140            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8141            * @throws SystemException if a system exception occurred
8142            */
8143            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
8144                    long id, long groupId, java.lang.String articleId, int status,
8145                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8146                    throws com.liferay.portal.kernel.exception.SystemException,
8147                            com.liferay.portlet.journal.NoSuchArticleException {
8148                    return getPersistence()
8149                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
8150                            status, orderByComparator);
8151            }
8152    
8153            /**
8154            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
8155            *
8156            * @param groupId the group ID
8157            * @param articleId the article ID
8158            * @param statuses the statuses
8159            * @return the matching journal articles that the user has permission to view
8160            * @throws SystemException if a system exception occurred
8161            */
8162            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
8163                    long groupId, java.lang.String articleId, int[] statuses)
8164                    throws com.liferay.portal.kernel.exception.SystemException {
8165                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
8166            }
8167    
8168            /**
8169            * 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;.
8170            *
8171            * <p>
8172            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8173            * </p>
8174            *
8175            * @param groupId the group ID
8176            * @param articleId the article ID
8177            * @param statuses the statuses
8178            * @param start the lower bound of the range of journal articles
8179            * @param end the upper bound of the range of journal articles (not inclusive)
8180            * @return the range of matching journal articles that the user has permission to view
8181            * @throws SystemException if a system exception occurred
8182            */
8183            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
8184                    long groupId, java.lang.String articleId, int[] statuses, int start,
8185                    int end) throws com.liferay.portal.kernel.exception.SystemException {
8186                    return getPersistence()
8187                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
8188            }
8189    
8190            /**
8191            * 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;.
8192            *
8193            * <p>
8194            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8195            * </p>
8196            *
8197            * @param groupId the group ID
8198            * @param articleId the article ID
8199            * @param statuses the statuses
8200            * @param start the lower bound of the range of journal articles
8201            * @param end the upper bound of the range of journal articles (not inclusive)
8202            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8203            * @return the ordered range of matching journal articles that the user has permission to view
8204            * @throws SystemException if a system exception occurred
8205            */
8206            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
8207                    long groupId, java.lang.String articleId, int[] statuses, int start,
8208                    int end,
8209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8210                    throws com.liferay.portal.kernel.exception.SystemException {
8211                    return getPersistence()
8212                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
8213                            end, orderByComparator);
8214            }
8215    
8216            /**
8217            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
8218            *
8219            * <p>
8220            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8221            * </p>
8222            *
8223            * @param groupId the group ID
8224            * @param articleId the article ID
8225            * @param statuses the statuses
8226            * @return the matching journal articles
8227            * @throws SystemException if a system exception occurred
8228            */
8229            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
8230                    long groupId, java.lang.String articleId, int[] statuses)
8231                    throws com.liferay.portal.kernel.exception.SystemException {
8232                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
8233            }
8234    
8235            /**
8236            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
8237            *
8238            * <p>
8239            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8240            * </p>
8241            *
8242            * @param groupId the group ID
8243            * @param articleId the article ID
8244            * @param statuses the statuses
8245            * @param start the lower bound of the range of journal articles
8246            * @param end the upper bound of the range of journal articles (not inclusive)
8247            * @return the range of matching journal articles
8248            * @throws SystemException if a system exception occurred
8249            */
8250            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
8251                    long groupId, java.lang.String articleId, int[] statuses, int start,
8252                    int end) throws com.liferay.portal.kernel.exception.SystemException {
8253                    return getPersistence()
8254                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
8255            }
8256    
8257            /**
8258            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
8259            *
8260            * <p>
8261            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8262            * </p>
8263            *
8264            * @param groupId the group ID
8265            * @param articleId the article ID
8266            * @param statuses the statuses
8267            * @param start the lower bound of the range of journal articles
8268            * @param end the upper bound of the range of journal articles (not inclusive)
8269            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8270            * @return the ordered range of matching journal articles
8271            * @throws SystemException if a system exception occurred
8272            */
8273            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
8274                    long groupId, java.lang.String articleId, int[] statuses, int start,
8275                    int end,
8276                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8277                    throws com.liferay.portal.kernel.exception.SystemException {
8278                    return getPersistence()
8279                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
8280                            orderByComparator);
8281            }
8282    
8283            /**
8284            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
8285            *
8286            * @param groupId the group ID
8287            * @param articleId the article ID
8288            * @param status the status
8289            * @throws SystemException if a system exception occurred
8290            */
8291            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
8292                    int status) throws com.liferay.portal.kernel.exception.SystemException {
8293                    getPersistence().removeByG_A_ST(groupId, articleId, status);
8294            }
8295    
8296            /**
8297            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
8298            *
8299            * @param groupId the group ID
8300            * @param articleId the article ID
8301            * @param status the status
8302            * @return the number of matching journal articles
8303            * @throws SystemException if a system exception occurred
8304            */
8305            public static int countByG_A_ST(long groupId, java.lang.String articleId,
8306                    int status) throws com.liferay.portal.kernel.exception.SystemException {
8307                    return getPersistence().countByG_A_ST(groupId, articleId, status);
8308            }
8309    
8310            /**
8311            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
8312            *
8313            * @param groupId the group ID
8314            * @param articleId the article ID
8315            * @param statuses the statuses
8316            * @return the number of matching journal articles
8317            * @throws SystemException if a system exception occurred
8318            */
8319            public static int countByG_A_ST(long groupId, java.lang.String articleId,
8320                    int[] statuses)
8321                    throws com.liferay.portal.kernel.exception.SystemException {
8322                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
8323            }
8324    
8325            /**
8326            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
8327            *
8328            * @param groupId the group ID
8329            * @param articleId the article ID
8330            * @param status the status
8331            * @return the number of matching journal articles that the user has permission to view
8332            * @throws SystemException if a system exception occurred
8333            */
8334            public static int filterCountByG_A_ST(long groupId,
8335                    java.lang.String articleId, int status)
8336                    throws com.liferay.portal.kernel.exception.SystemException {
8337                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
8338            }
8339    
8340            /**
8341            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
8342            *
8343            * @param groupId the group ID
8344            * @param articleId the article ID
8345            * @param statuses the statuses
8346            * @return the number of matching journal articles that the user has permission to view
8347            * @throws SystemException if a system exception occurred
8348            */
8349            public static int filterCountByG_A_ST(long groupId,
8350                    java.lang.String articleId, int[] statuses)
8351                    throws com.liferay.portal.kernel.exception.SystemException {
8352                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
8353            }
8354    
8355            /**
8356            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8357            *
8358            * @param groupId the group ID
8359            * @param articleId the article ID
8360            * @param status the status
8361            * @return the matching journal articles
8362            * @throws SystemException if a system exception occurred
8363            */
8364            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
8365                    long groupId, java.lang.String articleId, int status)
8366                    throws com.liferay.portal.kernel.exception.SystemException {
8367                    return getPersistence().findByG_A_NotST(groupId, articleId, status);
8368            }
8369    
8370            /**
8371            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8372            *
8373            * <p>
8374            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8375            * </p>
8376            *
8377            * @param groupId the group ID
8378            * @param articleId the article ID
8379            * @param status the status
8380            * @param start the lower bound of the range of journal articles
8381            * @param end the upper bound of the range of journal articles (not inclusive)
8382            * @return the range of matching journal articles
8383            * @throws SystemException if a system exception occurred
8384            */
8385            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
8386                    long groupId, java.lang.String articleId, int status, int start, int end)
8387                    throws com.liferay.portal.kernel.exception.SystemException {
8388                    return getPersistence()
8389                                       .findByG_A_NotST(groupId, articleId, status, start, end);
8390            }
8391    
8392            /**
8393            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8394            *
8395            * <p>
8396            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8397            * </p>
8398            *
8399            * @param groupId the group ID
8400            * @param articleId the article ID
8401            * @param status the status
8402            * @param start the lower bound of the range of journal articles
8403            * @param end the upper bound of the range of journal articles (not inclusive)
8404            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8405            * @return the ordered range of matching journal articles
8406            * @throws SystemException if a system exception occurred
8407            */
8408            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
8409                    long groupId, java.lang.String articleId, int status, int start,
8410                    int end,
8411                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8412                    throws com.liferay.portal.kernel.exception.SystemException {
8413                    return getPersistence()
8414                                       .findByG_A_NotST(groupId, articleId, status, start, end,
8415                            orderByComparator);
8416            }
8417    
8418            /**
8419            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8420            *
8421            * @param groupId the group ID
8422            * @param articleId the article ID
8423            * @param status the status
8424            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8425            * @return the first matching journal article
8426            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8427            * @throws SystemException if a system exception occurred
8428            */
8429            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_First(
8430                    long groupId, java.lang.String articleId, int status,
8431                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8432                    throws com.liferay.portal.kernel.exception.SystemException,
8433                            com.liferay.portlet.journal.NoSuchArticleException {
8434                    return getPersistence()
8435                                       .findByG_A_NotST_First(groupId, articleId, status,
8436                            orderByComparator);
8437            }
8438    
8439            /**
8440            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8441            *
8442            * @param groupId the group ID
8443            * @param articleId the article ID
8444            * @param status the status
8445            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8446            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
8447            * @throws SystemException if a system exception occurred
8448            */
8449            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_First(
8450                    long groupId, java.lang.String articleId, int status,
8451                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8452                    throws com.liferay.portal.kernel.exception.SystemException {
8453                    return getPersistence()
8454                                       .fetchByG_A_NotST_First(groupId, articleId, status,
8455                            orderByComparator);
8456            }
8457    
8458            /**
8459            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8460            *
8461            * @param groupId the group ID
8462            * @param articleId the article ID
8463            * @param status the status
8464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8465            * @return the last matching journal article
8466            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8467            * @throws SystemException if a system exception occurred
8468            */
8469            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_Last(
8470                    long groupId, java.lang.String articleId, int status,
8471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8472                    throws com.liferay.portal.kernel.exception.SystemException,
8473                            com.liferay.portlet.journal.NoSuchArticleException {
8474                    return getPersistence()
8475                                       .findByG_A_NotST_Last(groupId, articleId, status,
8476                            orderByComparator);
8477            }
8478    
8479            /**
8480            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8481            *
8482            * @param groupId the group ID
8483            * @param articleId the article ID
8484            * @param status the status
8485            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8486            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
8487            * @throws SystemException if a system exception occurred
8488            */
8489            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_Last(
8490                    long groupId, java.lang.String articleId, int status,
8491                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8492                    throws com.liferay.portal.kernel.exception.SystemException {
8493                    return getPersistence()
8494                                       .fetchByG_A_NotST_Last(groupId, articleId, status,
8495                            orderByComparator);
8496            }
8497    
8498            /**
8499            * 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;.
8500            *
8501            * @param id the primary key of the current journal article
8502            * @param groupId the group ID
8503            * @param articleId the article ID
8504            * @param status the status
8505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8506            * @return the previous, current, and next journal article
8507            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8508            * @throws SystemException if a system exception occurred
8509            */
8510            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_NotST_PrevAndNext(
8511                    long id, long groupId, java.lang.String articleId, int status,
8512                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8513                    throws com.liferay.portal.kernel.exception.SystemException,
8514                            com.liferay.portlet.journal.NoSuchArticleException {
8515                    return getPersistence()
8516                                       .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status,
8517                            orderByComparator);
8518            }
8519    
8520            /**
8521            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8522            *
8523            * @param groupId the group ID
8524            * @param articleId the article ID
8525            * @param status the status
8526            * @return the matching journal articles that the user has permission to view
8527            * @throws SystemException if a system exception occurred
8528            */
8529            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
8530                    long groupId, java.lang.String articleId, int status)
8531                    throws com.liferay.portal.kernel.exception.SystemException {
8532                    return getPersistence().filterFindByG_A_NotST(groupId, articleId, status);
8533            }
8534    
8535            /**
8536            * 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;.
8537            *
8538            * <p>
8539            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8540            * </p>
8541            *
8542            * @param groupId the group ID
8543            * @param articleId the article ID
8544            * @param status the status
8545            * @param start the lower bound of the range of journal articles
8546            * @param end the upper bound of the range of journal articles (not inclusive)
8547            * @return the range of matching journal articles that the user has permission to view
8548            * @throws SystemException if a system exception occurred
8549            */
8550            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
8551                    long groupId, java.lang.String articleId, int status, int start, int end)
8552                    throws com.liferay.portal.kernel.exception.SystemException {
8553                    return getPersistence()
8554                                       .filterFindByG_A_NotST(groupId, articleId, status, start, end);
8555            }
8556    
8557            /**
8558            * 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;.
8559            *
8560            * <p>
8561            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8562            * </p>
8563            *
8564            * @param groupId the group ID
8565            * @param articleId the article ID
8566            * @param status the status
8567            * @param start the lower bound of the range of journal articles
8568            * @param end the upper bound of the range of journal articles (not inclusive)
8569            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8570            * @return the ordered range of matching journal articles that the user has permission to view
8571            * @throws SystemException if a system exception occurred
8572            */
8573            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
8574                    long groupId, java.lang.String articleId, int status, int start,
8575                    int end,
8576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8577                    throws com.liferay.portal.kernel.exception.SystemException {
8578                    return getPersistence()
8579                                       .filterFindByG_A_NotST(groupId, articleId, status, start,
8580                            end, orderByComparator);
8581            }
8582    
8583            /**
8584            * 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;.
8585            *
8586            * @param id the primary key of the current journal article
8587            * @param groupId the group ID
8588            * @param articleId the article ID
8589            * @param status the status
8590            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8591            * @return the previous, current, and next journal article
8592            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8593            * @throws SystemException if a system exception occurred
8594            */
8595            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_NotST_PrevAndNext(
8596                    long id, long groupId, java.lang.String articleId, int status,
8597                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8598                    throws com.liferay.portal.kernel.exception.SystemException,
8599                            com.liferay.portlet.journal.NoSuchArticleException {
8600                    return getPersistence()
8601                                       .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId,
8602                            status, orderByComparator);
8603            }
8604    
8605            /**
8606            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63; from the database.
8607            *
8608            * @param groupId the group ID
8609            * @param articleId the article ID
8610            * @param status the status
8611            * @throws SystemException if a system exception occurred
8612            */
8613            public static void removeByG_A_NotST(long groupId,
8614                    java.lang.String articleId, int status)
8615                    throws com.liferay.portal.kernel.exception.SystemException {
8616                    getPersistence().removeByG_A_NotST(groupId, articleId, status);
8617            }
8618    
8619            /**
8620            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8621            *
8622            * @param groupId the group ID
8623            * @param articleId the article ID
8624            * @param status the status
8625            * @return the number of matching journal articles
8626            * @throws SystemException if a system exception occurred
8627            */
8628            public static int countByG_A_NotST(long groupId,
8629                    java.lang.String articleId, int status)
8630                    throws com.liferay.portal.kernel.exception.SystemException {
8631                    return getPersistence().countByG_A_NotST(groupId, articleId, status);
8632            }
8633    
8634            /**
8635            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
8636            *
8637            * @param groupId the group ID
8638            * @param articleId the article ID
8639            * @param status the status
8640            * @return the number of matching journal articles that the user has permission to view
8641            * @throws SystemException if a system exception occurred
8642            */
8643            public static int filterCountByG_A_NotST(long groupId,
8644                    java.lang.String articleId, int status)
8645                    throws com.liferay.portal.kernel.exception.SystemException {
8646                    return getPersistence()
8647                                       .filterCountByG_A_NotST(groupId, articleId, status);
8648            }
8649    
8650            /**
8651            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8652            *
8653            * @param groupId the group ID
8654            * @param urlTitle the url title
8655            * @param status the status
8656            * @return the matching journal articles
8657            * @throws SystemException if a system exception occurred
8658            */
8659            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
8660                    long groupId, java.lang.String urlTitle, int status)
8661                    throws com.liferay.portal.kernel.exception.SystemException {
8662                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
8663            }
8664    
8665            /**
8666            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8667            *
8668            * <p>
8669            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8670            * </p>
8671            *
8672            * @param groupId the group ID
8673            * @param urlTitle the url title
8674            * @param status the status
8675            * @param start the lower bound of the range of journal articles
8676            * @param end the upper bound of the range of journal articles (not inclusive)
8677            * @return the range of matching journal articles
8678            * @throws SystemException if a system exception occurred
8679            */
8680            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
8681                    long groupId, java.lang.String urlTitle, int status, int start, int end)
8682                    throws com.liferay.portal.kernel.exception.SystemException {
8683                    return getPersistence()
8684                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
8685            }
8686    
8687            /**
8688            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8689            *
8690            * <p>
8691            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8692            * </p>
8693            *
8694            * @param groupId the group ID
8695            * @param urlTitle the url title
8696            * @param status the status
8697            * @param start the lower bound of the range of journal articles
8698            * @param end the upper bound of the range of journal articles (not inclusive)
8699            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8700            * @return the ordered range of matching journal articles
8701            * @throws SystemException if a system exception occurred
8702            */
8703            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
8704                    long groupId, java.lang.String urlTitle, int status, int start,
8705                    int end,
8706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8707                    throws com.liferay.portal.kernel.exception.SystemException {
8708                    return getPersistence()
8709                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
8710                            orderByComparator);
8711            }
8712    
8713            /**
8714            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8715            *
8716            * @param groupId the group ID
8717            * @param urlTitle the url title
8718            * @param status the status
8719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8720            * @return the first matching journal article
8721            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8722            * @throws SystemException if a system exception occurred
8723            */
8724            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
8725                    long groupId, java.lang.String urlTitle, int status,
8726                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8727                    throws com.liferay.portal.kernel.exception.SystemException,
8728                            com.liferay.portlet.journal.NoSuchArticleException {
8729                    return getPersistence()
8730                                       .findByG_UT_ST_First(groupId, urlTitle, status,
8731                            orderByComparator);
8732            }
8733    
8734            /**
8735            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8736            *
8737            * @param groupId the group ID
8738            * @param urlTitle the url title
8739            * @param status the status
8740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8741            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
8742            * @throws SystemException if a system exception occurred
8743            */
8744            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
8745                    long groupId, java.lang.String urlTitle, int status,
8746                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8747                    throws com.liferay.portal.kernel.exception.SystemException {
8748                    return getPersistence()
8749                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
8750                            orderByComparator);
8751            }
8752    
8753            /**
8754            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8755            *
8756            * @param groupId the group ID
8757            * @param urlTitle the url title
8758            * @param status the status
8759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8760            * @return the last matching journal article
8761            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
8762            * @throws SystemException if a system exception occurred
8763            */
8764            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
8765                    long groupId, java.lang.String urlTitle, int status,
8766                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8767                    throws com.liferay.portal.kernel.exception.SystemException,
8768                            com.liferay.portlet.journal.NoSuchArticleException {
8769                    return getPersistence()
8770                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
8771                            orderByComparator);
8772            }
8773    
8774            /**
8775            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8776            *
8777            * @param groupId the group ID
8778            * @param urlTitle the url title
8779            * @param status the status
8780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8781            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
8782            * @throws SystemException if a system exception occurred
8783            */
8784            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
8785                    long groupId, java.lang.String urlTitle, int status,
8786                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8787                    throws com.liferay.portal.kernel.exception.SystemException {
8788                    return getPersistence()
8789                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
8790                            orderByComparator);
8791            }
8792    
8793            /**
8794            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8795            *
8796            * @param id the primary key of the current journal article
8797            * @param groupId the group ID
8798            * @param urlTitle the url title
8799            * @param status the status
8800            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8801            * @return the previous, current, and next journal article
8802            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8803            * @throws SystemException if a system exception occurred
8804            */
8805            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
8806                    long id, long groupId, java.lang.String urlTitle, int status,
8807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8808                    throws com.liferay.portal.kernel.exception.SystemException,
8809                            com.liferay.portlet.journal.NoSuchArticleException {
8810                    return getPersistence()
8811                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
8812                            orderByComparator);
8813            }
8814    
8815            /**
8816            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8817            *
8818            * @param groupId the group ID
8819            * @param urlTitle the url title
8820            * @param status the status
8821            * @return the matching journal articles that the user has permission to view
8822            * @throws SystemException if a system exception occurred
8823            */
8824            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
8825                    long groupId, java.lang.String urlTitle, int status)
8826                    throws com.liferay.portal.kernel.exception.SystemException {
8827                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
8828            }
8829    
8830            /**
8831            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8832            *
8833            * <p>
8834            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8835            * </p>
8836            *
8837            * @param groupId the group ID
8838            * @param urlTitle the url title
8839            * @param status the status
8840            * @param start the lower bound of the range of journal articles
8841            * @param end the upper bound of the range of journal articles (not inclusive)
8842            * @return the range of matching journal articles that the user has permission to view
8843            * @throws SystemException if a system exception occurred
8844            */
8845            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
8846                    long groupId, java.lang.String urlTitle, int status, int start, int end)
8847                    throws com.liferay.portal.kernel.exception.SystemException {
8848                    return getPersistence()
8849                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
8850            }
8851    
8852            /**
8853            * 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;.
8854            *
8855            * <p>
8856            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8857            * </p>
8858            *
8859            * @param groupId the group ID
8860            * @param urlTitle the url title
8861            * @param status the status
8862            * @param start the lower bound of the range of journal articles
8863            * @param end the upper bound of the range of journal articles (not inclusive)
8864            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8865            * @return the ordered range of matching journal articles that the user has permission to view
8866            * @throws SystemException if a system exception occurred
8867            */
8868            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
8869                    long groupId, java.lang.String urlTitle, int status, int start,
8870                    int end,
8871                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8872                    throws com.liferay.portal.kernel.exception.SystemException {
8873                    return getPersistence()
8874                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
8875                            orderByComparator);
8876            }
8877    
8878            /**
8879            * 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;.
8880            *
8881            * @param id the primary key of the current journal article
8882            * @param groupId the group ID
8883            * @param urlTitle the url title
8884            * @param status the status
8885            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
8886            * @return the previous, current, and next journal article
8887            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
8888            * @throws SystemException if a system exception occurred
8889            */
8890            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
8891                    long id, long groupId, java.lang.String urlTitle, int status,
8892                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8893                    throws com.liferay.portal.kernel.exception.SystemException,
8894                            com.liferay.portlet.journal.NoSuchArticleException {
8895                    return getPersistence()
8896                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
8897                            status, orderByComparator);
8898            }
8899    
8900            /**
8901            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
8902            *
8903            * @param groupId the group ID
8904            * @param urlTitle the url title
8905            * @param status the status
8906            * @throws SystemException if a system exception occurred
8907            */
8908            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
8909                    int status) throws com.liferay.portal.kernel.exception.SystemException {
8910                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
8911            }
8912    
8913            /**
8914            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8915            *
8916            * @param groupId the group ID
8917            * @param urlTitle the url title
8918            * @param status the status
8919            * @return the number of matching journal articles
8920            * @throws SystemException if a system exception occurred
8921            */
8922            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
8923                    int status) throws com.liferay.portal.kernel.exception.SystemException {
8924                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
8925            }
8926    
8927            /**
8928            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
8929            *
8930            * @param groupId the group ID
8931            * @param urlTitle the url title
8932            * @param status the status
8933            * @return the number of matching journal articles that the user has permission to view
8934            * @throws SystemException if a system exception occurred
8935            */
8936            public static int filterCountByG_UT_ST(long groupId,
8937                    java.lang.String urlTitle, int status)
8938                    throws com.liferay.portal.kernel.exception.SystemException {
8939                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
8940            }
8941    
8942            /**
8943            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8944            *
8945            * @param companyId the company ID
8946            * @param version the version
8947            * @param status the status
8948            * @return the matching journal articles
8949            * @throws SystemException if a system exception occurred
8950            */
8951            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
8952                    long companyId, double version, int status)
8953                    throws com.liferay.portal.kernel.exception.SystemException {
8954                    return getPersistence().findByC_V_ST(companyId, version, status);
8955            }
8956    
8957            /**
8958            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8959            *
8960            * <p>
8961            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8962            * </p>
8963            *
8964            * @param companyId the company ID
8965            * @param version the version
8966            * @param status the status
8967            * @param start the lower bound of the range of journal articles
8968            * @param end the upper bound of the range of journal articles (not inclusive)
8969            * @return the range of matching journal articles
8970            * @throws SystemException if a system exception occurred
8971            */
8972            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
8973                    long companyId, double version, int status, int start, int end)
8974                    throws com.liferay.portal.kernel.exception.SystemException {
8975                    return getPersistence()
8976                                       .findByC_V_ST(companyId, version, status, start, end);
8977            }
8978    
8979            /**
8980            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
8981            *
8982            * <p>
8983            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
8984            * </p>
8985            *
8986            * @param companyId the company ID
8987            * @param version the version
8988            * @param status the status
8989            * @param start the lower bound of the range of journal articles
8990            * @param end the upper bound of the range of journal articles (not inclusive)
8991            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
8992            * @return the ordered range of matching journal articles
8993            * @throws SystemException if a system exception occurred
8994            */
8995            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
8996                    long companyId, double version, int status, int start, int end,
8997                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
8998                    throws com.liferay.portal.kernel.exception.SystemException {
8999                    return getPersistence()
9000                                       .findByC_V_ST(companyId, version, status, start, end,
9001                            orderByComparator);
9002            }
9003    
9004            /**
9005            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
9006            *
9007            * @param companyId the company ID
9008            * @param version the version
9009            * @param status the status
9010            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
9011            * @return the first matching journal article
9012            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
9013            * @throws SystemException if a system exception occurred
9014            */
9015            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
9016                    long companyId, double version, int status,
9017                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
9018                    throws com.liferay.portal.kernel.exception.SystemException,
9019                            com.liferay.portlet.journal.NoSuchArticleException {
9020                    return getPersistence()
9021                                       .findByC_V_ST_First(companyId, version, status,
9022                            orderByComparator);
9023            }
9024    
9025            /**
9026            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
9027            *
9028            * @param companyId the company ID
9029            * @param version the version
9030            * @param status the status
9031            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
9032            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
9033            * @throws SystemException if a system exception occurred
9034            */
9035            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
9036                    long companyId, double version, int status,
9037                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
9038                    throws com.liferay.portal.kernel.exception.SystemException {
9039                    return getPersistence()
9040                                       .fetchByC_V_ST_First(companyId, version, status,
9041                            orderByComparator);
9042            }
9043    
9044            /**
9045            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
9046            *
9047            * @param companyId the company ID
9048            * @param version the version
9049            * @param status the status
9050            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
9051            * @return the last matching journal article
9052            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
9053            * @throws SystemException if a system exception occurred
9054            */
9055            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
9056                    long companyId, double version, int status,
9057                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
9058                    throws com.liferay.portal.kernel.exception.SystemException,
9059                            com.liferay.portlet.journal.NoSuchArticleException {
9060                    return getPersistence()
9061                                       .findByC_V_ST_Last(companyId, version, status,
9062                            orderByComparator);
9063            }
9064    
9065            /**
9066            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
9067            *
9068            * @param companyId the company ID
9069            * @param version the version
9070            * @param status the status
9071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
9072            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
9073            * @throws SystemException if a system exception occurred
9074            */
9075            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
9076                    long companyId, double version, int status,
9077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
9078                    throws com.liferay.portal.kernel.exception.SystemException {
9079                    return getPersistence()
9080                                       .fetchByC_V_ST_Last(companyId, version, status,
9081                            orderByComparator);
9082            }
9083    
9084            /**
9085            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
9086            *
9087            * @param id the primary key of the current journal article
9088            * @param companyId the company ID
9089            * @param version the version
9090            * @param status the status
9091            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
9092            * @return the previous, current, and next journal article
9093            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
9094            * @throws SystemException if a system exception occurred
9095            */
9096            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
9097                    long id, long companyId, double version, int status,
9098                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
9099                    throws com.liferay.portal.kernel.exception.SystemException,
9100                            com.liferay.portlet.journal.NoSuchArticleException {
9101                    return getPersistence()
9102                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
9103                            orderByComparator);
9104            }
9105    
9106            /**
9107            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
9108            *
9109            * @param companyId the company ID
9110            * @param version the version
9111            * @param status the status
9112            * @throws SystemException if a system exception occurred
9113            */
9114            public static void removeByC_V_ST(long companyId, double version, int status)
9115                    throws com.liferay.portal.kernel.exception.SystemException {
9116                    getPersistence().removeByC_V_ST(companyId, version, status);
9117            }
9118    
9119            /**
9120            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
9121            *
9122            * @param companyId the company ID
9123            * @param version the version
9124            * @param status the status
9125            * @return the number of matching journal articles
9126            * @throws SystemException if a system exception occurred
9127            */
9128            public static int countByC_V_ST(long companyId, double version, int status)
9129                    throws com.liferay.portal.kernel.exception.SystemException {
9130                    return getPersistence().countByC_V_ST(companyId, version, status);
9131            }
9132    
9133            /**
9134            * Caches the journal article in the entity cache if it is enabled.
9135            *
9136            * @param journalArticle the journal article
9137            */
9138            public static void cacheResult(
9139                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
9140                    getPersistence().cacheResult(journalArticle);
9141            }
9142    
9143            /**
9144            * Caches the journal articles in the entity cache if it is enabled.
9145            *
9146            * @param journalArticles the journal articles
9147            */
9148            public static void cacheResult(
9149                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
9150                    getPersistence().cacheResult(journalArticles);
9151            }
9152    
9153            /**
9154            * Creates a new journal article with the primary key. Does not add the journal article to the database.
9155            *
9156            * @param id the primary key for the new journal article
9157            * @return the new journal article
9158            */
9159            public static com.liferay.portlet.journal.model.JournalArticle create(
9160                    long id) {
9161                    return getPersistence().create(id);
9162            }
9163    
9164            /**
9165            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
9166            *
9167            * @param id the primary key of the journal article
9168            * @return the journal article that was removed
9169            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
9170            * @throws SystemException if a system exception occurred
9171            */
9172            public static com.liferay.portlet.journal.model.JournalArticle remove(
9173                    long id)
9174                    throws com.liferay.portal.kernel.exception.SystemException,
9175                            com.liferay.portlet.journal.NoSuchArticleException {
9176                    return getPersistence().remove(id);
9177            }
9178    
9179            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
9180                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
9181                    throws com.liferay.portal.kernel.exception.SystemException {
9182                    return getPersistence().updateImpl(journalArticle);
9183            }
9184    
9185            /**
9186            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
9187            *
9188            * @param id the primary key of the journal article
9189            * @return the journal article
9190            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
9191            * @throws SystemException if a system exception occurred
9192            */
9193            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
9194                    long id)
9195                    throws com.liferay.portal.kernel.exception.SystemException,
9196                            com.liferay.portlet.journal.NoSuchArticleException {
9197                    return getPersistence().findByPrimaryKey(id);
9198            }
9199    
9200            /**
9201            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
9202            *
9203            * @param id the primary key of the journal article
9204            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
9205            * @throws SystemException if a system exception occurred
9206            */
9207            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
9208                    long id) throws com.liferay.portal.kernel.exception.SystemException {
9209                    return getPersistence().fetchByPrimaryKey(id);
9210            }
9211    
9212            /**
9213            * Returns all the journal articles.
9214            *
9215            * @return the journal articles
9216            * @throws SystemException if a system exception occurred
9217            */
9218            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
9219                    throws com.liferay.portal.kernel.exception.SystemException {
9220                    return getPersistence().findAll();
9221            }
9222    
9223            /**
9224            * Returns a range of all the journal articles.
9225            *
9226            * <p>
9227            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
9228            * </p>
9229            *
9230            * @param start the lower bound of the range of journal articles
9231            * @param end the upper bound of the range of journal articles (not inclusive)
9232            * @return the range of journal articles
9233            * @throws SystemException if a system exception occurred
9234            */
9235            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
9236                    int start, int end)
9237                    throws com.liferay.portal.kernel.exception.SystemException {
9238                    return getPersistence().findAll(start, end);
9239            }
9240    
9241            /**
9242            * Returns an ordered range of all the journal articles.
9243            *
9244            * <p>
9245            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
9246            * </p>
9247            *
9248            * @param start the lower bound of the range of journal articles
9249            * @param end the upper bound of the range of journal articles (not inclusive)
9250            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
9251            * @return the ordered range of journal articles
9252            * @throws SystemException if a system exception occurred
9253            */
9254            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
9255                    int start, int end,
9256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
9257                    throws com.liferay.portal.kernel.exception.SystemException {
9258                    return getPersistence().findAll(start, end, orderByComparator);
9259            }
9260    
9261            /**
9262            * Removes all the journal articles from the database.
9263            *
9264            * @throws SystemException if a system exception occurred
9265            */
9266            public static void removeAll()
9267                    throws com.liferay.portal.kernel.exception.SystemException {
9268                    getPersistence().removeAll();
9269            }
9270    
9271            /**
9272            * Returns the number of journal articles.
9273            *
9274            * @return the number of journal articles
9275            * @throws SystemException if a system exception occurred
9276            */
9277            public static int countAll()
9278                    throws com.liferay.portal.kernel.exception.SystemException {
9279                    return getPersistence().countAll();
9280            }
9281    
9282            public static JournalArticlePersistence getPersistence() {
9283                    if (_persistence == null) {
9284                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
9285    
9286                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
9287                                    "_persistence");
9288                    }
9289    
9290                    return _persistence;
9291            }
9292    
9293            /**
9294             * @deprecated As of 6.2.0
9295             */
9296            public void setPersistence(JournalArticlePersistence persistence) {
9297            }
9298    
9299            private static JournalArticlePersistence _persistence;
9300    }