001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.journal.model.JournalArticle;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see JournalArticlePersistence
037     * @see JournalArticlePersistenceImpl
038     * @generated
039     */
040    public class JournalArticleUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(JournalArticle journalArticle) {
058                    getPersistence().clearCache(journalArticle);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<JournalArticle> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<JournalArticle> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalArticle> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static JournalArticle update(JournalArticle journalArticle)
101                    throws SystemException {
102                    return getPersistence().update(journalArticle);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static JournalArticle update(JournalArticle journalArticle,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(journalArticle, serviceContext);
111            }
112    
113            /**
114            * Returns all the journal articles where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching journal articles
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the journal articles where uuid = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of journal articles
135            * @param end the upper bound of the range of journal articles (not inclusive)
136            * @return the range of matching journal articles
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the journal articles where uuid = &#63;.
147            *
148            * <p>
149            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of journal articles
154            * @param end the upper bound of the range of journal articles (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching journal articles
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first journal article in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching journal article
172            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.kernel.exception.SystemException,
179                            com.liferay.portlet.journal.NoSuchArticleException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first journal article in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last journal article in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching journal article
204            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.kernel.exception.SystemException,
211                            com.liferay.portlet.journal.NoSuchArticleException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last journal article in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
232            *
233            * @param id the primary key of the current journal article
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next journal article
237            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
241                    long id, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException,
244                            com.liferay.portlet.journal.NoSuchArticleException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the journal articles where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of journal articles where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching journal articles
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching journal article
278            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.journal.NoSuchArticleException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
290            *
291            * @param uuid the uuid
292            * @param groupId the group ID
293            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
297                    java.lang.String uuid, long groupId)
298                    throws com.liferay.portal.kernel.exception.SystemException {
299                    return getPersistence().fetchByUUID_G(uuid, groupId);
300            }
301    
302            /**
303            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @param retrieveFromCache whether to use the finder cache
308            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
312                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
315            }
316    
317            /**
318            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param groupId the group ID
322            * @return the journal article that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.journal.NoSuchArticleException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param groupId the group ID
337            * @return the number of matching journal articles
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUUID_G(java.lang.String uuid, long groupId)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching journal articles
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
354                    java.lang.String uuid, long companyId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().findByUuid_C(uuid, companyId);
357            }
358    
359            /**
360            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of journal articles
369            * @param end the upper bound of the range of journal articles (not inclusive)
370            * @return the range of matching journal articles
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
374                    java.lang.String uuid, long companyId, int start, int end)
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
377            }
378    
379            /**
380            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
381            *
382            * <p>
383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
384            * </p>
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param start the lower bound of the range of journal articles
389            * @param end the upper bound of the range of journal articles (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching journal articles
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
395                    java.lang.String uuid, long companyId, int start, int end,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence()
399                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
400            }
401    
402            /**
403            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching journal article
409            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First(
413                    java.lang.String uuid, long companyId,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.kernel.exception.SystemException,
416                            com.liferay.portlet.journal.NoSuchArticleException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First(
431                    java.lang.String uuid, long companyId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException {
434                    return getPersistence()
435                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
436            }
437    
438            /**
439            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching journal article
445            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last(
449                    java.lang.String uuid, long companyId,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.journal.NoSuchArticleException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last(
467                    java.lang.String uuid, long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
472            }
473    
474            /**
475            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param id the primary key of the current journal article
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next journal article
482            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext(
486                    long id, java.lang.String uuid, long companyId,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException,
489                            com.liferay.portlet.journal.NoSuchArticleException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @throws SystemException if a system exception occurred
501            */
502            public static void removeByUuid_C(java.lang.String uuid, long companyId)
503                    throws com.liferay.portal.kernel.exception.SystemException {
504                    getPersistence().removeByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the number of matching journal articles
513            * @throws SystemException if a system exception occurred
514            */
515            public static int countByUuid_C(java.lang.String uuid, long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().countByUuid_C(uuid, companyId);
518            }
519    
520            /**
521            * Returns all the journal articles where resourcePrimKey = &#63;.
522            *
523            * @param resourcePrimKey the resource prim key
524            * @return the matching journal articles
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
528                    long resourcePrimKey)
529                    throws com.liferay.portal.kernel.exception.SystemException {
530                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
531            }
532    
533            /**
534            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
535            *
536            * <p>
537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
538            * </p>
539            *
540            * @param resourcePrimKey the resource prim key
541            * @param start the lower bound of the range of journal articles
542            * @param end the upper bound of the range of journal articles (not inclusive)
543            * @return the range of matching journal articles
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
547                    long resourcePrimKey, int start, int end)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence()
550                                       .findByResourcePrimKey(resourcePrimKey, start, end);
551            }
552    
553            /**
554            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
555            *
556            * <p>
557            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
558            * </p>
559            *
560            * @param resourcePrimKey the resource prim key
561            * @param start the lower bound of the range of journal articles
562            * @param end the upper bound of the range of journal articles (not inclusive)
563            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
564            * @return the ordered range of matching journal articles
565            * @throws SystemException if a system exception occurred
566            */
567            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
568                    long resourcePrimKey, int start, int end,
569                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
570                    throws com.liferay.portal.kernel.exception.SystemException {
571                    return getPersistence()
572                                       .findByResourcePrimKey(resourcePrimKey, start, end,
573                            orderByComparator);
574            }
575    
576            /**
577            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
578            *
579            * @param resourcePrimKey the resource prim key
580            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
581            * @return the first matching journal article
582            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
583            * @throws SystemException if a system exception occurred
584            */
585            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
586                    long resourcePrimKey,
587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
588                    throws com.liferay.portal.kernel.exception.SystemException,
589                            com.liferay.portlet.journal.NoSuchArticleException {
590                    return getPersistence()
591                                       .findByResourcePrimKey_First(resourcePrimKey,
592                            orderByComparator);
593            }
594    
595            /**
596            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
597            *
598            * @param resourcePrimKey the resource prim key
599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
600            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
601            * @throws SystemException if a system exception occurred
602            */
603            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First(
604                    long resourcePrimKey,
605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
606                    throws com.liferay.portal.kernel.exception.SystemException {
607                    return getPersistence()
608                                       .fetchByResourcePrimKey_First(resourcePrimKey,
609                            orderByComparator);
610            }
611    
612            /**
613            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
614            *
615            * @param resourcePrimKey the resource prim key
616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
617            * @return the last matching journal article
618            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
619            * @throws SystemException if a system exception occurred
620            */
621            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
622                    long resourcePrimKey,
623                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
624                    throws com.liferay.portal.kernel.exception.SystemException,
625                            com.liferay.portlet.journal.NoSuchArticleException {
626                    return getPersistence()
627                                       .findByResourcePrimKey_Last(resourcePrimKey,
628                            orderByComparator);
629            }
630    
631            /**
632            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
633            *
634            * @param resourcePrimKey the resource prim key
635            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
636            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
637            * @throws SystemException if a system exception occurred
638            */
639            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last(
640                    long resourcePrimKey,
641                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
642                    throws com.liferay.portal.kernel.exception.SystemException {
643                    return getPersistence()
644                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
645                            orderByComparator);
646            }
647    
648            /**
649            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
650            *
651            * @param id the primary key of the current journal article
652            * @param resourcePrimKey the resource prim key
653            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
654            * @return the previous, current, and next journal article
655            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
656            * @throws SystemException if a system exception occurred
657            */
658            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
659                    long id, long resourcePrimKey,
660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
661                    throws com.liferay.portal.kernel.exception.SystemException,
662                            com.liferay.portlet.journal.NoSuchArticleException {
663                    return getPersistence()
664                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
665                            orderByComparator);
666            }
667    
668            /**
669            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
670            *
671            * @param resourcePrimKey the resource prim key
672            * @throws SystemException if a system exception occurred
673            */
674            public static void removeByResourcePrimKey(long resourcePrimKey)
675                    throws com.liferay.portal.kernel.exception.SystemException {
676                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
677            }
678    
679            /**
680            * Returns the number of journal articles where resourcePrimKey = &#63;.
681            *
682            * @param resourcePrimKey the resource prim key
683            * @return the number of matching journal articles
684            * @throws SystemException if a system exception occurred
685            */
686            public static int countByResourcePrimKey(long resourcePrimKey)
687                    throws com.liferay.portal.kernel.exception.SystemException {
688                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
689            }
690    
691            /**
692            * Returns all the journal articles where groupId = &#63;.
693            *
694            * @param groupId the group ID
695            * @return the matching journal articles
696            * @throws SystemException if a system exception occurred
697            */
698            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
699                    long groupId)
700                    throws com.liferay.portal.kernel.exception.SystemException {
701                    return getPersistence().findByGroupId(groupId);
702            }
703    
704            /**
705            * Returns a range of all the journal articles where groupId = &#63;.
706            *
707            * <p>
708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
709            * </p>
710            *
711            * @param groupId the group ID
712            * @param start the lower bound of the range of journal articles
713            * @param end the upper bound of the range of journal articles (not inclusive)
714            * @return the range of matching journal articles
715            * @throws SystemException if a system exception occurred
716            */
717            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
718                    long groupId, int start, int end)
719                    throws com.liferay.portal.kernel.exception.SystemException {
720                    return getPersistence().findByGroupId(groupId, start, end);
721            }
722    
723            /**
724            * Returns an ordered range of all the journal articles where groupId = &#63;.
725            *
726            * <p>
727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
728            * </p>
729            *
730            * @param groupId the group ID
731            * @param start the lower bound of the range of journal articles
732            * @param end the upper bound of the range of journal articles (not inclusive)
733            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
734            * @return the ordered range of matching journal articles
735            * @throws SystemException if a system exception occurred
736            */
737            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
738                    long groupId, int start, int end,
739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
740                    throws com.liferay.portal.kernel.exception.SystemException {
741                    return getPersistence()
742                                       .findByGroupId(groupId, start, end, orderByComparator);
743            }
744    
745            /**
746            * Returns the first journal article in the ordered set where groupId = &#63;.
747            *
748            * @param groupId the group ID
749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
750            * @return the first matching journal article
751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
752            * @throws SystemException if a system exception occurred
753            */
754            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
755                    long groupId,
756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
757                    throws com.liferay.portal.kernel.exception.SystemException,
758                            com.liferay.portlet.journal.NoSuchArticleException {
759                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
760            }
761    
762            /**
763            * Returns the first journal article in the ordered set where groupId = &#63;.
764            *
765            * @param groupId the group ID
766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
767            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
768            * @throws SystemException if a system exception occurred
769            */
770            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First(
771                    long groupId,
772                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
773                    throws com.liferay.portal.kernel.exception.SystemException {
774                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
775            }
776    
777            /**
778            * Returns the last journal article in the ordered set where groupId = &#63;.
779            *
780            * @param groupId the group ID
781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
782            * @return the last matching journal article
783            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
784            * @throws SystemException if a system exception occurred
785            */
786            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
787                    long groupId,
788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
789                    throws com.liferay.portal.kernel.exception.SystemException,
790                            com.liferay.portlet.journal.NoSuchArticleException {
791                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
792            }
793    
794            /**
795            * Returns the last journal article in the ordered set where groupId = &#63;.
796            *
797            * @param groupId the group ID
798            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
799            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
800            * @throws SystemException if a system exception occurred
801            */
802            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last(
803                    long groupId,
804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
805                    throws com.liferay.portal.kernel.exception.SystemException {
806                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
807            }
808    
809            /**
810            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
811            *
812            * @param id the primary key of the current journal article
813            * @param groupId the group ID
814            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
815            * @return the previous, current, and next journal article
816            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
817            * @throws SystemException if a system exception occurred
818            */
819            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
820                    long id, long groupId,
821                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
822                    throws com.liferay.portal.kernel.exception.SystemException,
823                            com.liferay.portlet.journal.NoSuchArticleException {
824                    return getPersistence()
825                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
826            }
827    
828            /**
829            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
830            *
831            * @param groupId the group ID
832            * @return the matching journal articles that the user has permission to view
833            * @throws SystemException if a system exception occurred
834            */
835            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
836                    long groupId)
837                    throws com.liferay.portal.kernel.exception.SystemException {
838                    return getPersistence().filterFindByGroupId(groupId);
839            }
840    
841            /**
842            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
843            *
844            * <p>
845            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
846            * </p>
847            *
848            * @param groupId the group ID
849            * @param start the lower bound of the range of journal articles
850            * @param end the upper bound of the range of journal articles (not inclusive)
851            * @return the range of matching journal articles that the user has permission to view
852            * @throws SystemException if a system exception occurred
853            */
854            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
855                    long groupId, int start, int end)
856                    throws com.liferay.portal.kernel.exception.SystemException {
857                    return getPersistence().filterFindByGroupId(groupId, start, end);
858            }
859    
860            /**
861            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
862            *
863            * <p>
864            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
865            * </p>
866            *
867            * @param groupId the group ID
868            * @param start the lower bound of the range of journal articles
869            * @param end the upper bound of the range of journal articles (not inclusive)
870            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
871            * @return the ordered range of matching journal articles that the user has permission to view
872            * @throws SystemException if a system exception occurred
873            */
874            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
875                    long groupId, int start, int end,
876                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
877                    throws com.liferay.portal.kernel.exception.SystemException {
878                    return getPersistence()
879                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
880            }
881    
882            /**
883            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63;.
884            *
885            * @param id the primary key of the current journal article
886            * @param groupId the group ID
887            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
888            * @return the previous, current, and next journal article
889            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
890            * @throws SystemException if a system exception occurred
891            */
892            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
893                    long id, long groupId,
894                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
895                    throws com.liferay.portal.kernel.exception.SystemException,
896                            com.liferay.portlet.journal.NoSuchArticleException {
897                    return getPersistence()
898                                       .filterFindByGroupId_PrevAndNext(id, groupId,
899                            orderByComparator);
900            }
901    
902            /**
903            * Removes all the journal articles where groupId = &#63; from the database.
904            *
905            * @param groupId the group ID
906            * @throws SystemException if a system exception occurred
907            */
908            public static void removeByGroupId(long groupId)
909                    throws com.liferay.portal.kernel.exception.SystemException {
910                    getPersistence().removeByGroupId(groupId);
911            }
912    
913            /**
914            * Returns the number of journal articles where groupId = &#63;.
915            *
916            * @param groupId the group ID
917            * @return the number of matching journal articles
918            * @throws SystemException if a system exception occurred
919            */
920            public static int countByGroupId(long groupId)
921                    throws com.liferay.portal.kernel.exception.SystemException {
922                    return getPersistence().countByGroupId(groupId);
923            }
924    
925            /**
926            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
927            *
928            * @param groupId the group ID
929            * @return the number of matching journal articles that the user has permission to view
930            * @throws SystemException if a system exception occurred
931            */
932            public static int filterCountByGroupId(long groupId)
933                    throws com.liferay.portal.kernel.exception.SystemException {
934                    return getPersistence().filterCountByGroupId(groupId);
935            }
936    
937            /**
938            * Returns all the journal articles where companyId = &#63;.
939            *
940            * @param companyId the company ID
941            * @return the matching journal articles
942            * @throws SystemException if a system exception occurred
943            */
944            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
945                    long companyId)
946                    throws com.liferay.portal.kernel.exception.SystemException {
947                    return getPersistence().findByCompanyId(companyId);
948            }
949    
950            /**
951            * Returns a range of all the journal articles where companyId = &#63;.
952            *
953            * <p>
954            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
955            * </p>
956            *
957            * @param companyId the company ID
958            * @param start the lower bound of the range of journal articles
959            * @param end the upper bound of the range of journal articles (not inclusive)
960            * @return the range of matching journal articles
961            * @throws SystemException if a system exception occurred
962            */
963            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
964                    long companyId, int start, int end)
965                    throws com.liferay.portal.kernel.exception.SystemException {
966                    return getPersistence().findByCompanyId(companyId, start, end);
967            }
968    
969            /**
970            * Returns an ordered range of all the journal articles where companyId = &#63;.
971            *
972            * <p>
973            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
974            * </p>
975            *
976            * @param companyId the company ID
977            * @param start the lower bound of the range of journal articles
978            * @param end the upper bound of the range of journal articles (not inclusive)
979            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
980            * @return the ordered range of matching journal articles
981            * @throws SystemException if a system exception occurred
982            */
983            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
984                    long companyId, int start, int end,
985                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
986                    throws com.liferay.portal.kernel.exception.SystemException {
987                    return getPersistence()
988                                       .findByCompanyId(companyId, start, end, orderByComparator);
989            }
990    
991            /**
992            * Returns the first journal article in the ordered set where companyId = &#63;.
993            *
994            * @param companyId the company ID
995            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
996            * @return the first matching journal article
997            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
998            * @throws SystemException if a system exception occurred
999            */
1000            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
1001                    long companyId,
1002                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1003                    throws com.liferay.portal.kernel.exception.SystemException,
1004                            com.liferay.portlet.journal.NoSuchArticleException {
1005                    return getPersistence()
1006                                       .findByCompanyId_First(companyId, orderByComparator);
1007            }
1008    
1009            /**
1010            * Returns the first journal article in the ordered set where companyId = &#63;.
1011            *
1012            * @param companyId the company ID
1013            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1014            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1015            * @throws SystemException if a system exception occurred
1016            */
1017            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First(
1018                    long companyId,
1019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1020                    throws com.liferay.portal.kernel.exception.SystemException {
1021                    return getPersistence()
1022                                       .fetchByCompanyId_First(companyId, orderByComparator);
1023            }
1024    
1025            /**
1026            * Returns the last journal article in the ordered set where companyId = &#63;.
1027            *
1028            * @param companyId the company ID
1029            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1030            * @return the last matching journal article
1031            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1032            * @throws SystemException if a system exception occurred
1033            */
1034            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
1035                    long companyId,
1036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1037                    throws com.liferay.portal.kernel.exception.SystemException,
1038                            com.liferay.portlet.journal.NoSuchArticleException {
1039                    return getPersistence()
1040                                       .findByCompanyId_Last(companyId, orderByComparator);
1041            }
1042    
1043            /**
1044            * Returns the last journal article in the ordered set where companyId = &#63;.
1045            *
1046            * @param companyId the company ID
1047            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1048            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1049            * @throws SystemException if a system exception occurred
1050            */
1051            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last(
1052                    long companyId,
1053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1054                    throws com.liferay.portal.kernel.exception.SystemException {
1055                    return getPersistence()
1056                                       .fetchByCompanyId_Last(companyId, orderByComparator);
1057            }
1058    
1059            /**
1060            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
1061            *
1062            * @param id the primary key of the current journal article
1063            * @param companyId the company ID
1064            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1065            * @return the previous, current, and next journal article
1066            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1067            * @throws SystemException if a system exception occurred
1068            */
1069            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
1070                    long id, long companyId,
1071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1072                    throws com.liferay.portal.kernel.exception.SystemException,
1073                            com.liferay.portlet.journal.NoSuchArticleException {
1074                    return getPersistence()
1075                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
1076            }
1077    
1078            /**
1079            * Removes all the journal articles where companyId = &#63; from the database.
1080            *
1081            * @param companyId the company ID
1082            * @throws SystemException if a system exception occurred
1083            */
1084            public static void removeByCompanyId(long companyId)
1085                    throws com.liferay.portal.kernel.exception.SystemException {
1086                    getPersistence().removeByCompanyId(companyId);
1087            }
1088    
1089            /**
1090            * Returns the number of journal articles where companyId = &#63;.
1091            *
1092            * @param companyId the company ID
1093            * @return the number of matching journal articles
1094            * @throws SystemException if a system exception occurred
1095            */
1096            public static int countByCompanyId(long companyId)
1097                    throws com.liferay.portal.kernel.exception.SystemException {
1098                    return getPersistence().countByCompanyId(companyId);
1099            }
1100    
1101            /**
1102            * Returns all the journal articles where structureId = &#63;.
1103            *
1104            * @param structureId the structure ID
1105            * @return the matching journal articles
1106            * @throws SystemException if a system exception occurred
1107            */
1108            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1109                    java.lang.String structureId)
1110                    throws com.liferay.portal.kernel.exception.SystemException {
1111                    return getPersistence().findByStructureId(structureId);
1112            }
1113    
1114            /**
1115            * Returns a range of all the journal articles where structureId = &#63;.
1116            *
1117            * <p>
1118            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1119            * </p>
1120            *
1121            * @param structureId the structure ID
1122            * @param start the lower bound of the range of journal articles
1123            * @param end the upper bound of the range of journal articles (not inclusive)
1124            * @return the range of matching journal articles
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1128                    java.lang.String structureId, int start, int end)
1129                    throws com.liferay.portal.kernel.exception.SystemException {
1130                    return getPersistence().findByStructureId(structureId, start, end);
1131            }
1132    
1133            /**
1134            * Returns an ordered range of all the journal articles where structureId = &#63;.
1135            *
1136            * <p>
1137            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1138            * </p>
1139            *
1140            * @param structureId the structure ID
1141            * @param start the lower bound of the range of journal articles
1142            * @param end the upper bound of the range of journal articles (not inclusive)
1143            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1144            * @return the ordered range of matching journal articles
1145            * @throws SystemException if a system exception occurred
1146            */
1147            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1148                    java.lang.String structureId, int start, int end,
1149                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1150                    throws com.liferay.portal.kernel.exception.SystemException {
1151                    return getPersistence()
1152                                       .findByStructureId(structureId, start, end, orderByComparator);
1153            }
1154    
1155            /**
1156            * Returns the first journal article in the ordered set where structureId = &#63;.
1157            *
1158            * @param structureId the structure ID
1159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1160            * @return the first matching journal article
1161            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1162            * @throws SystemException if a system exception occurred
1163            */
1164            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
1165                    java.lang.String structureId,
1166                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1167                    throws com.liferay.portal.kernel.exception.SystemException,
1168                            com.liferay.portlet.journal.NoSuchArticleException {
1169                    return getPersistence()
1170                                       .findByStructureId_First(structureId, orderByComparator);
1171            }
1172    
1173            /**
1174            * Returns the first journal article in the ordered set where structureId = &#63;.
1175            *
1176            * @param structureId the structure ID
1177            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1178            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1179            * @throws SystemException if a system exception occurred
1180            */
1181            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First(
1182                    java.lang.String structureId,
1183                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1184                    throws com.liferay.portal.kernel.exception.SystemException {
1185                    return getPersistence()
1186                                       .fetchByStructureId_First(structureId, orderByComparator);
1187            }
1188    
1189            /**
1190            * Returns the last journal article in the ordered set where structureId = &#63;.
1191            *
1192            * @param structureId the structure ID
1193            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1194            * @return the last matching journal article
1195            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1196            * @throws SystemException if a system exception occurred
1197            */
1198            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
1199                    java.lang.String structureId,
1200                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1201                    throws com.liferay.portal.kernel.exception.SystemException,
1202                            com.liferay.portlet.journal.NoSuchArticleException {
1203                    return getPersistence()
1204                                       .findByStructureId_Last(structureId, orderByComparator);
1205            }
1206    
1207            /**
1208            * Returns the last journal article in the ordered set where structureId = &#63;.
1209            *
1210            * @param structureId the structure ID
1211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1212            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1213            * @throws SystemException if a system exception occurred
1214            */
1215            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last(
1216                    java.lang.String structureId,
1217                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1218                    throws com.liferay.portal.kernel.exception.SystemException {
1219                    return getPersistence()
1220                                       .fetchByStructureId_Last(structureId, orderByComparator);
1221            }
1222    
1223            /**
1224            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
1225            *
1226            * @param id the primary key of the current journal article
1227            * @param structureId the structure ID
1228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1229            * @return the previous, current, and next journal article
1230            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1231            * @throws SystemException if a system exception occurred
1232            */
1233            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
1234                    long id, java.lang.String structureId,
1235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1236                    throws com.liferay.portal.kernel.exception.SystemException,
1237                            com.liferay.portlet.journal.NoSuchArticleException {
1238                    return getPersistence()
1239                                       .findByStructureId_PrevAndNext(id, structureId,
1240                            orderByComparator);
1241            }
1242    
1243            /**
1244            * Returns all the journal articles where structureId = any &#63;.
1245            *
1246            * <p>
1247            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1248            * </p>
1249            *
1250            * @param structureIds the structure IDs
1251            * @return the matching journal articles
1252            * @throws SystemException if a system exception occurred
1253            */
1254            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1255                    java.lang.String[] structureIds)
1256                    throws com.liferay.portal.kernel.exception.SystemException {
1257                    return getPersistence().findByStructureId(structureIds);
1258            }
1259    
1260            /**
1261            * Returns a range of all the journal articles where structureId = any &#63;.
1262            *
1263            * <p>
1264            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1265            * </p>
1266            *
1267            * @param structureIds the structure IDs
1268            * @param start the lower bound of the range of journal articles
1269            * @param end the upper bound of the range of journal articles (not inclusive)
1270            * @return the range of matching journal articles
1271            * @throws SystemException if a system exception occurred
1272            */
1273            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1274                    java.lang.String[] structureIds, int start, int end)
1275                    throws com.liferay.portal.kernel.exception.SystemException {
1276                    return getPersistence().findByStructureId(structureIds, start, end);
1277            }
1278    
1279            /**
1280            * Returns an ordered range of all the journal articles where structureId = any &#63;.
1281            *
1282            * <p>
1283            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1284            * </p>
1285            *
1286            * @param structureIds the structure IDs
1287            * @param start the lower bound of the range of journal articles
1288            * @param end the upper bound of the range of journal articles (not inclusive)
1289            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1290            * @return the ordered range of matching journal articles
1291            * @throws SystemException if a system exception occurred
1292            */
1293            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1294                    java.lang.String[] structureIds, int start, int end,
1295                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1296                    throws com.liferay.portal.kernel.exception.SystemException {
1297                    return getPersistence()
1298                                       .findByStructureId(structureIds, start, end,
1299                            orderByComparator);
1300            }
1301    
1302            /**
1303            * Removes all the journal articles where structureId = &#63; from the database.
1304            *
1305            * @param structureId the structure ID
1306            * @throws SystemException if a system exception occurred
1307            */
1308            public static void removeByStructureId(java.lang.String structureId)
1309                    throws com.liferay.portal.kernel.exception.SystemException {
1310                    getPersistence().removeByStructureId(structureId);
1311            }
1312    
1313            /**
1314            * Returns the number of journal articles where structureId = &#63;.
1315            *
1316            * @param structureId the structure ID
1317            * @return the number of matching journal articles
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static int countByStructureId(java.lang.String structureId)
1321                    throws com.liferay.portal.kernel.exception.SystemException {
1322                    return getPersistence().countByStructureId(structureId);
1323            }
1324    
1325            /**
1326            * Returns the number of journal articles where structureId = any &#63;.
1327            *
1328            * @param structureIds the structure IDs
1329            * @return the number of matching journal articles
1330            * @throws SystemException if a system exception occurred
1331            */
1332            public static int countByStructureId(java.lang.String[] structureIds)
1333                    throws com.liferay.portal.kernel.exception.SystemException {
1334                    return getPersistence().countByStructureId(structureIds);
1335            }
1336    
1337            /**
1338            * Returns all the journal articles where templateId = &#63;.
1339            *
1340            * @param templateId the template ID
1341            * @return the matching journal articles
1342            * @throws SystemException if a system exception occurred
1343            */
1344            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1345                    java.lang.String templateId)
1346                    throws com.liferay.portal.kernel.exception.SystemException {
1347                    return getPersistence().findByTemplateId(templateId);
1348            }
1349    
1350            /**
1351            * Returns a range of all the journal articles where templateId = &#63;.
1352            *
1353            * <p>
1354            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1355            * </p>
1356            *
1357            * @param templateId the template ID
1358            * @param start the lower bound of the range of journal articles
1359            * @param end the upper bound of the range of journal articles (not inclusive)
1360            * @return the range of matching journal articles
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1364                    java.lang.String templateId, int start, int end)
1365                    throws com.liferay.portal.kernel.exception.SystemException {
1366                    return getPersistence().findByTemplateId(templateId, start, end);
1367            }
1368    
1369            /**
1370            * Returns an ordered range of all the journal articles where templateId = &#63;.
1371            *
1372            * <p>
1373            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1374            * </p>
1375            *
1376            * @param templateId the template ID
1377            * @param start the lower bound of the range of journal articles
1378            * @param end the upper bound of the range of journal articles (not inclusive)
1379            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1380            * @return the ordered range of matching journal articles
1381            * @throws SystemException if a system exception occurred
1382            */
1383            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1384                    java.lang.String templateId, int start, int end,
1385                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1386                    throws com.liferay.portal.kernel.exception.SystemException {
1387                    return getPersistence()
1388                                       .findByTemplateId(templateId, start, end, orderByComparator);
1389            }
1390    
1391            /**
1392            * Returns the first journal article in the ordered set where templateId = &#63;.
1393            *
1394            * @param templateId the template ID
1395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1396            * @return the first matching journal article
1397            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1398            * @throws SystemException if a system exception occurred
1399            */
1400            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1401                    java.lang.String templateId,
1402                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1403                    throws com.liferay.portal.kernel.exception.SystemException,
1404                            com.liferay.portlet.journal.NoSuchArticleException {
1405                    return getPersistence()
1406                                       .findByTemplateId_First(templateId, orderByComparator);
1407            }
1408    
1409            /**
1410            * Returns the first journal article in the ordered set where templateId = &#63;.
1411            *
1412            * @param templateId the template ID
1413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1414            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1415            * @throws SystemException if a system exception occurred
1416            */
1417            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1418                    java.lang.String templateId,
1419                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1420                    throws com.liferay.portal.kernel.exception.SystemException {
1421                    return getPersistence()
1422                                       .fetchByTemplateId_First(templateId, orderByComparator);
1423            }
1424    
1425            /**
1426            * Returns the last journal article in the ordered set where templateId = &#63;.
1427            *
1428            * @param templateId the template ID
1429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1430            * @return the last matching journal article
1431            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1432            * @throws SystemException if a system exception occurred
1433            */
1434            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1435                    java.lang.String templateId,
1436                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1437                    throws com.liferay.portal.kernel.exception.SystemException,
1438                            com.liferay.portlet.journal.NoSuchArticleException {
1439                    return getPersistence()
1440                                       .findByTemplateId_Last(templateId, orderByComparator);
1441            }
1442    
1443            /**
1444            * Returns the last journal article in the ordered set where templateId = &#63;.
1445            *
1446            * @param templateId the template ID
1447            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1448            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1449            * @throws SystemException if a system exception occurred
1450            */
1451            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1452                    java.lang.String templateId,
1453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1454                    throws com.liferay.portal.kernel.exception.SystemException {
1455                    return getPersistence()
1456                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1457            }
1458    
1459            /**
1460            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1461            *
1462            * @param id the primary key of the current journal article
1463            * @param templateId the template ID
1464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1465            * @return the previous, current, and next journal article
1466            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1467            * @throws SystemException if a system exception occurred
1468            */
1469            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1470                    long id, java.lang.String templateId,
1471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1472                    throws com.liferay.portal.kernel.exception.SystemException,
1473                            com.liferay.portlet.journal.NoSuchArticleException {
1474                    return getPersistence()
1475                                       .findByTemplateId_PrevAndNext(id, templateId,
1476                            orderByComparator);
1477            }
1478    
1479            /**
1480            * Removes all the journal articles where templateId = &#63; from the database.
1481            *
1482            * @param templateId the template ID
1483            * @throws SystemException if a system exception occurred
1484            */
1485            public static void removeByTemplateId(java.lang.String templateId)
1486                    throws com.liferay.portal.kernel.exception.SystemException {
1487                    getPersistence().removeByTemplateId(templateId);
1488            }
1489    
1490            /**
1491            * Returns the number of journal articles where templateId = &#63;.
1492            *
1493            * @param templateId the template ID
1494            * @return the number of matching journal articles
1495            * @throws SystemException if a system exception occurred
1496            */
1497            public static int countByTemplateId(java.lang.String templateId)
1498                    throws com.liferay.portal.kernel.exception.SystemException {
1499                    return getPersistence().countByTemplateId(templateId);
1500            }
1501    
1502            /**
1503            * Returns all the journal articles where layoutUuid = &#63;.
1504            *
1505            * @param layoutUuid the layout uuid
1506            * @return the matching journal articles
1507            * @throws SystemException if a system exception occurred
1508            */
1509            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1510                    java.lang.String layoutUuid)
1511                    throws com.liferay.portal.kernel.exception.SystemException {
1512                    return getPersistence().findByLayoutUuid(layoutUuid);
1513            }
1514    
1515            /**
1516            * Returns a range of all the journal articles where layoutUuid = &#63;.
1517            *
1518            * <p>
1519            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1520            * </p>
1521            *
1522            * @param layoutUuid the layout uuid
1523            * @param start the lower bound of the range of journal articles
1524            * @param end the upper bound of the range of journal articles (not inclusive)
1525            * @return the range of matching journal articles
1526            * @throws SystemException if a system exception occurred
1527            */
1528            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1529                    java.lang.String layoutUuid, int start, int end)
1530                    throws com.liferay.portal.kernel.exception.SystemException {
1531                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1532            }
1533    
1534            /**
1535            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1536            *
1537            * <p>
1538            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1539            * </p>
1540            *
1541            * @param layoutUuid the layout uuid
1542            * @param start the lower bound of the range of journal articles
1543            * @param end the upper bound of the range of journal articles (not inclusive)
1544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1545            * @return the ordered range of matching journal articles
1546            * @throws SystemException if a system exception occurred
1547            */
1548            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1549                    java.lang.String layoutUuid, int start, int end,
1550                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1551                    throws com.liferay.portal.kernel.exception.SystemException {
1552                    return getPersistence()
1553                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1554            }
1555    
1556            /**
1557            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1558            *
1559            * @param layoutUuid the layout uuid
1560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1561            * @return the first matching journal article
1562            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1563            * @throws SystemException if a system exception occurred
1564            */
1565            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First(
1566                    java.lang.String layoutUuid,
1567                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1568                    throws com.liferay.portal.kernel.exception.SystemException,
1569                            com.liferay.portlet.journal.NoSuchArticleException {
1570                    return getPersistence()
1571                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1572            }
1573    
1574            /**
1575            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1576            *
1577            * @param layoutUuid the layout uuid
1578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1579            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1580            * @throws SystemException if a system exception occurred
1581            */
1582            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First(
1583                    java.lang.String layoutUuid,
1584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1585                    throws com.liferay.portal.kernel.exception.SystemException {
1586                    return getPersistence()
1587                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1588            }
1589    
1590            /**
1591            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1592            *
1593            * @param layoutUuid the layout uuid
1594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1595            * @return the last matching journal article
1596            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last(
1600                    java.lang.String layoutUuid,
1601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1602                    throws com.liferay.portal.kernel.exception.SystemException,
1603                            com.liferay.portlet.journal.NoSuchArticleException {
1604                    return getPersistence()
1605                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1606            }
1607    
1608            /**
1609            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1610            *
1611            * @param layoutUuid the layout uuid
1612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1613            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1614            * @throws SystemException if a system exception occurred
1615            */
1616            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last(
1617                    java.lang.String layoutUuid,
1618                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1619                    throws com.liferay.portal.kernel.exception.SystemException {
1620                    return getPersistence()
1621                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1622            }
1623    
1624            /**
1625            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1626            *
1627            * @param id the primary key of the current journal article
1628            * @param layoutUuid the layout uuid
1629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1630            * @return the previous, current, and next journal article
1631            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1632            * @throws SystemException if a system exception occurred
1633            */
1634            public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext(
1635                    long id, java.lang.String layoutUuid,
1636                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1637                    throws com.liferay.portal.kernel.exception.SystemException,
1638                            com.liferay.portlet.journal.NoSuchArticleException {
1639                    return getPersistence()
1640                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1641                            orderByComparator);
1642            }
1643    
1644            /**
1645            * Removes all the journal articles where layoutUuid = &#63; from the database.
1646            *
1647            * @param layoutUuid the layout uuid
1648            * @throws SystemException if a system exception occurred
1649            */
1650            public static void removeByLayoutUuid(java.lang.String layoutUuid)
1651                    throws com.liferay.portal.kernel.exception.SystemException {
1652                    getPersistence().removeByLayoutUuid(layoutUuid);
1653            }
1654    
1655            /**
1656            * Returns the number of journal articles where layoutUuid = &#63;.
1657            *
1658            * @param layoutUuid the layout uuid
1659            * @return the number of matching journal articles
1660            * @throws SystemException if a system exception occurred
1661            */
1662            public static int countByLayoutUuid(java.lang.String layoutUuid)
1663                    throws com.liferay.portal.kernel.exception.SystemException {
1664                    return getPersistence().countByLayoutUuid(layoutUuid);
1665            }
1666    
1667            /**
1668            * Returns all the journal articles where smallImageId = &#63;.
1669            *
1670            * @param smallImageId the small image ID
1671            * @return the matching journal articles
1672            * @throws SystemException if a system exception occurred
1673            */
1674            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1675                    long smallImageId)
1676                    throws com.liferay.portal.kernel.exception.SystemException {
1677                    return getPersistence().findBySmallImageId(smallImageId);
1678            }
1679    
1680            /**
1681            * Returns a range of all the journal articles where smallImageId = &#63;.
1682            *
1683            * <p>
1684            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1685            * </p>
1686            *
1687            * @param smallImageId the small image ID
1688            * @param start the lower bound of the range of journal articles
1689            * @param end the upper bound of the range of journal articles (not inclusive)
1690            * @return the range of matching journal articles
1691            * @throws SystemException if a system exception occurred
1692            */
1693            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1694                    long smallImageId, int start, int end)
1695                    throws com.liferay.portal.kernel.exception.SystemException {
1696                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1697            }
1698    
1699            /**
1700            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1701            *
1702            * <p>
1703            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1704            * </p>
1705            *
1706            * @param smallImageId the small image ID
1707            * @param start the lower bound of the range of journal articles
1708            * @param end the upper bound of the range of journal articles (not inclusive)
1709            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1710            * @return the ordered range of matching journal articles
1711            * @throws SystemException if a system exception occurred
1712            */
1713            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1714                    long smallImageId, int start, int end,
1715                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1716                    throws com.liferay.portal.kernel.exception.SystemException {
1717                    return getPersistence()
1718                                       .findBySmallImageId(smallImageId, start, end,
1719                            orderByComparator);
1720            }
1721    
1722            /**
1723            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1724            *
1725            * @param smallImageId the small image ID
1726            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1727            * @return the first matching journal article
1728            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1729            * @throws SystemException if a system exception occurred
1730            */
1731            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1732                    long smallImageId,
1733                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1734                    throws com.liferay.portal.kernel.exception.SystemException,
1735                            com.liferay.portlet.journal.NoSuchArticleException {
1736                    return getPersistence()
1737                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1738            }
1739    
1740            /**
1741            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1742            *
1743            * @param smallImageId the small image ID
1744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1745            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1746            * @throws SystemException if a system exception occurred
1747            */
1748            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1749                    long smallImageId,
1750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1751                    throws com.liferay.portal.kernel.exception.SystemException {
1752                    return getPersistence()
1753                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1754            }
1755    
1756            /**
1757            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1758            *
1759            * @param smallImageId the small image ID
1760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1761            * @return the last matching journal article
1762            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1763            * @throws SystemException if a system exception occurred
1764            */
1765            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1766                    long smallImageId,
1767                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1768                    throws com.liferay.portal.kernel.exception.SystemException,
1769                            com.liferay.portlet.journal.NoSuchArticleException {
1770                    return getPersistence()
1771                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1772            }
1773    
1774            /**
1775            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1776            *
1777            * @param smallImageId the small image ID
1778            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1779            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1780            * @throws SystemException if a system exception occurred
1781            */
1782            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1783                    long smallImageId,
1784                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1785                    throws com.liferay.portal.kernel.exception.SystemException {
1786                    return getPersistence()
1787                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1788            }
1789    
1790            /**
1791            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1792            *
1793            * @param id the primary key of the current journal article
1794            * @param smallImageId the small image ID
1795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1796            * @return the previous, current, and next journal article
1797            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1798            * @throws SystemException if a system exception occurred
1799            */
1800            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1801                    long id, long smallImageId,
1802                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1803                    throws com.liferay.portal.kernel.exception.SystemException,
1804                            com.liferay.portlet.journal.NoSuchArticleException {
1805                    return getPersistence()
1806                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1807                            orderByComparator);
1808            }
1809    
1810            /**
1811            * Removes all the journal articles where smallImageId = &#63; from the database.
1812            *
1813            * @param smallImageId the small image ID
1814            * @throws SystemException if a system exception occurred
1815            */
1816            public static void removeBySmallImageId(long smallImageId)
1817                    throws com.liferay.portal.kernel.exception.SystemException {
1818                    getPersistence().removeBySmallImageId(smallImageId);
1819            }
1820    
1821            /**
1822            * Returns the number of journal articles where smallImageId = &#63;.
1823            *
1824            * @param smallImageId the small image ID
1825            * @return the number of matching journal articles
1826            * @throws SystemException if a system exception occurred
1827            */
1828            public static int countBySmallImageId(long smallImageId)
1829                    throws com.liferay.portal.kernel.exception.SystemException {
1830                    return getPersistence().countBySmallImageId(smallImageId);
1831            }
1832    
1833            /**
1834            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1835            *
1836            * @param resourcePrimKey the resource prim key
1837            * @param status the status
1838            * @return the matching journal articles
1839            * @throws SystemException if a system exception occurred
1840            */
1841            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1842                    long resourcePrimKey, int status)
1843                    throws com.liferay.portal.kernel.exception.SystemException {
1844                    return getPersistence().findByR_ST(resourcePrimKey, status);
1845            }
1846    
1847            /**
1848            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1849            *
1850            * <p>
1851            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1852            * </p>
1853            *
1854            * @param resourcePrimKey the resource prim key
1855            * @param status the status
1856            * @param start the lower bound of the range of journal articles
1857            * @param end the upper bound of the range of journal articles (not inclusive)
1858            * @return the range of matching journal articles
1859            * @throws SystemException if a system exception occurred
1860            */
1861            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1862                    long resourcePrimKey, int status, int start, int end)
1863                    throws com.liferay.portal.kernel.exception.SystemException {
1864                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1865            }
1866    
1867            /**
1868            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1869            *
1870            * <p>
1871            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1872            * </p>
1873            *
1874            * @param resourcePrimKey the resource prim key
1875            * @param status the status
1876            * @param start the lower bound of the range of journal articles
1877            * @param end the upper bound of the range of journal articles (not inclusive)
1878            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1879            * @return the ordered range of matching journal articles
1880            * @throws SystemException if a system exception occurred
1881            */
1882            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1883                    long resourcePrimKey, int status, int start, int end,
1884                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1885                    throws com.liferay.portal.kernel.exception.SystemException {
1886                    return getPersistence()
1887                                       .findByR_ST(resourcePrimKey, status, start, end,
1888                            orderByComparator);
1889            }
1890    
1891            /**
1892            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1893            *
1894            * @param resourcePrimKey the resource prim key
1895            * @param status the status
1896            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1897            * @return the first matching journal article
1898            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1899            * @throws SystemException if a system exception occurred
1900            */
1901            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1902                    long resourcePrimKey, int status,
1903                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1904                    throws com.liferay.portal.kernel.exception.SystemException,
1905                            com.liferay.portlet.journal.NoSuchArticleException {
1906                    return getPersistence()
1907                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1908            }
1909    
1910            /**
1911            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1912            *
1913            * @param resourcePrimKey the resource prim key
1914            * @param status the status
1915            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1916            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1917            * @throws SystemException if a system exception occurred
1918            */
1919            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
1920                    long resourcePrimKey, int status,
1921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1922                    throws com.liferay.portal.kernel.exception.SystemException {
1923                    return getPersistence()
1924                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
1925            }
1926    
1927            /**
1928            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1929            *
1930            * @param resourcePrimKey the resource prim key
1931            * @param status the status
1932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1933            * @return the last matching journal article
1934            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1935            * @throws SystemException if a system exception occurred
1936            */
1937            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1938                    long resourcePrimKey, int status,
1939                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1940                    throws com.liferay.portal.kernel.exception.SystemException,
1941                            com.liferay.portlet.journal.NoSuchArticleException {
1942                    return getPersistence()
1943                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1944            }
1945    
1946            /**
1947            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1948            *
1949            * @param resourcePrimKey the resource prim key
1950            * @param status the status
1951            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1952            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1953            * @throws SystemException if a system exception occurred
1954            */
1955            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
1956                    long resourcePrimKey, int status,
1957                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1958                    throws com.liferay.portal.kernel.exception.SystemException {
1959                    return getPersistence()
1960                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
1961            }
1962    
1963            /**
1964            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1965            *
1966            * @param id the primary key of the current journal article
1967            * @param resourcePrimKey the resource prim key
1968            * @param status the status
1969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1970            * @return the previous, current, and next journal article
1971            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1972            * @throws SystemException if a system exception occurred
1973            */
1974            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1975                    long id, long resourcePrimKey, int status,
1976                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1977                    throws com.liferay.portal.kernel.exception.SystemException,
1978                            com.liferay.portlet.journal.NoSuchArticleException {
1979                    return getPersistence()
1980                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1981                            orderByComparator);
1982            }
1983    
1984            /**
1985            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
1986            *
1987            * @param resourcePrimKey the resource prim key
1988            * @param status the status
1989            * @throws SystemException if a system exception occurred
1990            */
1991            public static void removeByR_ST(long resourcePrimKey, int status)
1992                    throws com.liferay.portal.kernel.exception.SystemException {
1993                    getPersistence().removeByR_ST(resourcePrimKey, status);
1994            }
1995    
1996            /**
1997            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
1998            *
1999            * @param resourcePrimKey the resource prim key
2000            * @param status the status
2001            * @return the number of matching journal articles
2002            * @throws SystemException if a system exception occurred
2003            */
2004            public static int countByR_ST(long resourcePrimKey, int status)
2005                    throws com.liferay.portal.kernel.exception.SystemException {
2006                    return getPersistence().countByR_ST(resourcePrimKey, status);
2007            }
2008    
2009            /**
2010            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
2011            *
2012            * @param groupId the group ID
2013            * @param userId the user ID
2014            * @return the matching journal articles
2015            * @throws SystemException if a system exception occurred
2016            */
2017            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2018                    long groupId, long userId)
2019                    throws com.liferay.portal.kernel.exception.SystemException {
2020                    return getPersistence().findByG_U(groupId, userId);
2021            }
2022    
2023            /**
2024            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
2025            *
2026            * <p>
2027            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2028            * </p>
2029            *
2030            * @param groupId the group ID
2031            * @param userId the user ID
2032            * @param start the lower bound of the range of journal articles
2033            * @param end the upper bound of the range of journal articles (not inclusive)
2034            * @return the range of matching journal articles
2035            * @throws SystemException if a system exception occurred
2036            */
2037            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2038                    long groupId, long userId, int start, int end)
2039                    throws com.liferay.portal.kernel.exception.SystemException {
2040                    return getPersistence().findByG_U(groupId, userId, start, end);
2041            }
2042    
2043            /**
2044            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
2045            *
2046            * <p>
2047            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2048            * </p>
2049            *
2050            * @param groupId the group ID
2051            * @param userId the user ID
2052            * @param start the lower bound of the range of journal articles
2053            * @param end the upper bound of the range of journal articles (not inclusive)
2054            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2055            * @return the ordered range of matching journal articles
2056            * @throws SystemException if a system exception occurred
2057            */
2058            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2059                    long groupId, long userId, int start, int end,
2060                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2061                    throws com.liferay.portal.kernel.exception.SystemException {
2062                    return getPersistence()
2063                                       .findByG_U(groupId, userId, start, end, orderByComparator);
2064            }
2065    
2066            /**
2067            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2068            *
2069            * @param groupId the group ID
2070            * @param userId the user ID
2071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2072            * @return the first matching journal article
2073            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2074            * @throws SystemException if a system exception occurred
2075            */
2076            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First(
2077                    long groupId, long userId,
2078                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2079                    throws com.liferay.portal.kernel.exception.SystemException,
2080                            com.liferay.portlet.journal.NoSuchArticleException {
2081                    return getPersistence()
2082                                       .findByG_U_First(groupId, userId, orderByComparator);
2083            }
2084    
2085            /**
2086            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2087            *
2088            * @param groupId the group ID
2089            * @param userId the user ID
2090            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2091            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2092            * @throws SystemException if a system exception occurred
2093            */
2094            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First(
2095                    long groupId, long userId,
2096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2097                    throws com.liferay.portal.kernel.exception.SystemException {
2098                    return getPersistence()
2099                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2100            }
2101    
2102            /**
2103            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2104            *
2105            * @param groupId the group ID
2106            * @param userId the user ID
2107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2108            * @return the last matching journal article
2109            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2110            * @throws SystemException if a system exception occurred
2111            */
2112            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last(
2113                    long groupId, long userId,
2114                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2115                    throws com.liferay.portal.kernel.exception.SystemException,
2116                            com.liferay.portlet.journal.NoSuchArticleException {
2117                    return getPersistence()
2118                                       .findByG_U_Last(groupId, userId, orderByComparator);
2119            }
2120    
2121            /**
2122            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2123            *
2124            * @param groupId the group ID
2125            * @param userId the user ID
2126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2127            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2128            * @throws SystemException if a system exception occurred
2129            */
2130            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last(
2131                    long groupId, long userId,
2132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2133                    throws com.liferay.portal.kernel.exception.SystemException {
2134                    return getPersistence()
2135                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2140            *
2141            * @param id the primary key of the current journal article
2142            * @param groupId the group ID
2143            * @param userId the user ID
2144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2145            * @return the previous, current, and next journal article
2146            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2147            * @throws SystemException if a system exception occurred
2148            */
2149            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext(
2150                    long id, long groupId, long userId,
2151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2152                    throws com.liferay.portal.kernel.exception.SystemException,
2153                            com.liferay.portlet.journal.NoSuchArticleException {
2154                    return getPersistence()
2155                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2156            }
2157    
2158            /**
2159            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2160            *
2161            * @param groupId the group ID
2162            * @param userId the user ID
2163            * @return the matching journal articles that the user has permission to view
2164            * @throws SystemException if a system exception occurred
2165            */
2166            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2167                    long groupId, long userId)
2168                    throws com.liferay.portal.kernel.exception.SystemException {
2169                    return getPersistence().filterFindByG_U(groupId, userId);
2170            }
2171    
2172            /**
2173            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2174            *
2175            * <p>
2176            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2177            * </p>
2178            *
2179            * @param groupId the group ID
2180            * @param userId the user ID
2181            * @param start the lower bound of the range of journal articles
2182            * @param end the upper bound of the range of journal articles (not inclusive)
2183            * @return the range of matching journal articles that the user has permission to view
2184            * @throws SystemException if a system exception occurred
2185            */
2186            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2187                    long groupId, long userId, int start, int end)
2188                    throws com.liferay.portal.kernel.exception.SystemException {
2189                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2190            }
2191    
2192            /**
2193            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2194            *
2195            * <p>
2196            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2197            * </p>
2198            *
2199            * @param groupId the group ID
2200            * @param userId the user ID
2201            * @param start the lower bound of the range of journal articles
2202            * @param end the upper bound of the range of journal articles (not inclusive)
2203            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2204            * @return the ordered range of matching journal articles that the user has permission to view
2205            * @throws SystemException if a system exception occurred
2206            */
2207            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2208                    long groupId, long userId, int start, int end,
2209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2210                    throws com.liferay.portal.kernel.exception.SystemException {
2211                    return getPersistence()
2212                                       .filterFindByG_U(groupId, userId, start, end,
2213                            orderByComparator);
2214            }
2215    
2216            /**
2217            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2218            *
2219            * @param id the primary key of the current journal article
2220            * @param groupId the group ID
2221            * @param userId the user ID
2222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2223            * @return the previous, current, and next journal article
2224            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2225            * @throws SystemException if a system exception occurred
2226            */
2227            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext(
2228                    long id, long groupId, long userId,
2229                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2230                    throws com.liferay.portal.kernel.exception.SystemException,
2231                            com.liferay.portlet.journal.NoSuchArticleException {
2232                    return getPersistence()
2233                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2234                            orderByComparator);
2235            }
2236    
2237            /**
2238            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2239            *
2240            * @param groupId the group ID
2241            * @param userId the user ID
2242            * @throws SystemException if a system exception occurred
2243            */
2244            public static void removeByG_U(long groupId, long userId)
2245                    throws com.liferay.portal.kernel.exception.SystemException {
2246                    getPersistence().removeByG_U(groupId, userId);
2247            }
2248    
2249            /**
2250            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2251            *
2252            * @param groupId the group ID
2253            * @param userId the user ID
2254            * @return the number of matching journal articles
2255            * @throws SystemException if a system exception occurred
2256            */
2257            public static int countByG_U(long groupId, long userId)
2258                    throws com.liferay.portal.kernel.exception.SystemException {
2259                    return getPersistence().countByG_U(groupId, userId);
2260            }
2261    
2262            /**
2263            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2264            *
2265            * @param groupId the group ID
2266            * @param userId the user ID
2267            * @return the number of matching journal articles that the user has permission to view
2268            * @throws SystemException if a system exception occurred
2269            */
2270            public static int filterCountByG_U(long groupId, long userId)
2271                    throws com.liferay.portal.kernel.exception.SystemException {
2272                    return getPersistence().filterCountByG_U(groupId, userId);
2273            }
2274    
2275            /**
2276            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2277            *
2278            * @param groupId the group ID
2279            * @param folderId the folder ID
2280            * @return the matching journal articles
2281            * @throws SystemException if a system exception occurred
2282            */
2283            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2284                    long groupId, long folderId)
2285                    throws com.liferay.portal.kernel.exception.SystemException {
2286                    return getPersistence().findByG_F(groupId, folderId);
2287            }
2288    
2289            /**
2290            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2291            *
2292            * <p>
2293            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2294            * </p>
2295            *
2296            * @param groupId the group ID
2297            * @param folderId the folder ID
2298            * @param start the lower bound of the range of journal articles
2299            * @param end the upper bound of the range of journal articles (not inclusive)
2300            * @return the range of matching journal articles
2301            * @throws SystemException if a system exception occurred
2302            */
2303            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2304                    long groupId, long folderId, int start, int end)
2305                    throws com.liferay.portal.kernel.exception.SystemException {
2306                    return getPersistence().findByG_F(groupId, folderId, start, end);
2307            }
2308    
2309            /**
2310            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2311            *
2312            * <p>
2313            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2314            * </p>
2315            *
2316            * @param groupId the group ID
2317            * @param folderId the folder ID
2318            * @param start the lower bound of the range of journal articles
2319            * @param end the upper bound of the range of journal articles (not inclusive)
2320            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2321            * @return the ordered range of matching journal articles
2322            * @throws SystemException if a system exception occurred
2323            */
2324            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2325                    long groupId, long folderId, int start, int end,
2326                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2327                    throws com.liferay.portal.kernel.exception.SystemException {
2328                    return getPersistence()
2329                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2330            }
2331    
2332            /**
2333            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2334            *
2335            * @param groupId the group ID
2336            * @param folderId the folder ID
2337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2338            * @return the first matching journal article
2339            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2340            * @throws SystemException if a system exception occurred
2341            */
2342            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First(
2343                    long groupId, long folderId,
2344                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2345                    throws com.liferay.portal.kernel.exception.SystemException,
2346                            com.liferay.portlet.journal.NoSuchArticleException {
2347                    return getPersistence()
2348                                       .findByG_F_First(groupId, folderId, orderByComparator);
2349            }
2350    
2351            /**
2352            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2353            *
2354            * @param groupId the group ID
2355            * @param folderId the folder ID
2356            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2357            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2358            * @throws SystemException if a system exception occurred
2359            */
2360            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First(
2361                    long groupId, long folderId,
2362                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2363                    throws com.liferay.portal.kernel.exception.SystemException {
2364                    return getPersistence()
2365                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2366            }
2367    
2368            /**
2369            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2370            *
2371            * @param groupId the group ID
2372            * @param folderId the folder ID
2373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2374            * @return the last matching journal article
2375            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2376            * @throws SystemException if a system exception occurred
2377            */
2378            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last(
2379                    long groupId, long folderId,
2380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2381                    throws com.liferay.portal.kernel.exception.SystemException,
2382                            com.liferay.portlet.journal.NoSuchArticleException {
2383                    return getPersistence()
2384                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2385            }
2386    
2387            /**
2388            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2389            *
2390            * @param groupId the group ID
2391            * @param folderId the folder ID
2392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2393            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2394            * @throws SystemException if a system exception occurred
2395            */
2396            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last(
2397                    long groupId, long folderId,
2398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2399                    throws com.liferay.portal.kernel.exception.SystemException {
2400                    return getPersistence()
2401                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2402            }
2403    
2404            /**
2405            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2406            *
2407            * @param id the primary key of the current journal article
2408            * @param groupId the group ID
2409            * @param folderId the folder ID
2410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2411            * @return the previous, current, and next journal article
2412            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2413            * @throws SystemException if a system exception occurred
2414            */
2415            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext(
2416                    long id, long groupId, long folderId,
2417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2418                    throws com.liferay.portal.kernel.exception.SystemException,
2419                            com.liferay.portlet.journal.NoSuchArticleException {
2420                    return getPersistence()
2421                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2422                            orderByComparator);
2423            }
2424    
2425            /**
2426            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2427            *
2428            * @param groupId the group ID
2429            * @param folderId the folder ID
2430            * @return the matching journal articles that the user has permission to view
2431            * @throws SystemException if a system exception occurred
2432            */
2433            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2434                    long groupId, long folderId)
2435                    throws com.liferay.portal.kernel.exception.SystemException {
2436                    return getPersistence().filterFindByG_F(groupId, folderId);
2437            }
2438    
2439            /**
2440            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2441            *
2442            * <p>
2443            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2444            * </p>
2445            *
2446            * @param groupId the group ID
2447            * @param folderId the folder ID
2448            * @param start the lower bound of the range of journal articles
2449            * @param end the upper bound of the range of journal articles (not inclusive)
2450            * @return the range of matching journal articles that the user has permission to view
2451            * @throws SystemException if a system exception occurred
2452            */
2453            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2454                    long groupId, long folderId, int start, int end)
2455                    throws com.liferay.portal.kernel.exception.SystemException {
2456                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2457            }
2458    
2459            /**
2460            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2461            *
2462            * <p>
2463            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2464            * </p>
2465            *
2466            * @param groupId the group ID
2467            * @param folderId the folder ID
2468            * @param start the lower bound of the range of journal articles
2469            * @param end the upper bound of the range of journal articles (not inclusive)
2470            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2471            * @return the ordered range of matching journal articles that the user has permission to view
2472            * @throws SystemException if a system exception occurred
2473            */
2474            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2475                    long groupId, long folderId, int start, int end,
2476                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2477                    throws com.liferay.portal.kernel.exception.SystemException {
2478                    return getPersistence()
2479                                       .filterFindByG_F(groupId, folderId, start, end,
2480                            orderByComparator);
2481            }
2482    
2483            /**
2484            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2485            *
2486            * @param id the primary key of the current journal article
2487            * @param groupId the group ID
2488            * @param folderId the folder ID
2489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2490            * @return the previous, current, and next journal article
2491            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2492            * @throws SystemException if a system exception occurred
2493            */
2494            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext(
2495                    long id, long groupId, long folderId,
2496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2497                    throws com.liferay.portal.kernel.exception.SystemException,
2498                            com.liferay.portlet.journal.NoSuchArticleException {
2499                    return getPersistence()
2500                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2501                            orderByComparator);
2502            }
2503    
2504            /**
2505            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2506            *
2507            * @param groupId the group ID
2508            * @param folderIds the folder IDs
2509            * @return the matching journal articles that the user has permission to view
2510            * @throws SystemException if a system exception occurred
2511            */
2512            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2513                    long groupId, long[] folderIds)
2514                    throws com.liferay.portal.kernel.exception.SystemException {
2515                    return getPersistence().filterFindByG_F(groupId, folderIds);
2516            }
2517    
2518            /**
2519            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2520            *
2521            * <p>
2522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2523            * </p>
2524            *
2525            * @param groupId the group ID
2526            * @param folderIds the folder IDs
2527            * @param start the lower bound of the range of journal articles
2528            * @param end the upper bound of the range of journal articles (not inclusive)
2529            * @return the range of matching journal articles that the user has permission to view
2530            * @throws SystemException if a system exception occurred
2531            */
2532            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2533                    long groupId, long[] folderIds, int start, int end)
2534                    throws com.liferay.portal.kernel.exception.SystemException {
2535                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2536            }
2537    
2538            /**
2539            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2540            *
2541            * <p>
2542            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2543            * </p>
2544            *
2545            * @param groupId the group ID
2546            * @param folderIds the folder IDs
2547            * @param start the lower bound of the range of journal articles
2548            * @param end the upper bound of the range of journal articles (not inclusive)
2549            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2550            * @return the ordered range of matching journal articles that the user has permission to view
2551            * @throws SystemException if a system exception occurred
2552            */
2553            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2554                    long groupId, long[] folderIds, int start, int end,
2555                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2556                    throws com.liferay.portal.kernel.exception.SystemException {
2557                    return getPersistence()
2558                                       .filterFindByG_F(groupId, folderIds, start, end,
2559                            orderByComparator);
2560            }
2561    
2562            /**
2563            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2564            *
2565            * <p>
2566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2567            * </p>
2568            *
2569            * @param groupId the group ID
2570            * @param folderIds the folder IDs
2571            * @return the matching journal articles
2572            * @throws SystemException if a system exception occurred
2573            */
2574            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2575                    long groupId, long[] folderIds)
2576                    throws com.liferay.portal.kernel.exception.SystemException {
2577                    return getPersistence().findByG_F(groupId, folderIds);
2578            }
2579    
2580            /**
2581            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2582            *
2583            * <p>
2584            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2585            * </p>
2586            *
2587            * @param groupId the group ID
2588            * @param folderIds the folder IDs
2589            * @param start the lower bound of the range of journal articles
2590            * @param end the upper bound of the range of journal articles (not inclusive)
2591            * @return the range of matching journal articles
2592            * @throws SystemException if a system exception occurred
2593            */
2594            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2595                    long groupId, long[] folderIds, int start, int end)
2596                    throws com.liferay.portal.kernel.exception.SystemException {
2597                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2598            }
2599    
2600            /**
2601            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2602            *
2603            * <p>
2604            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2605            * </p>
2606            *
2607            * @param groupId the group ID
2608            * @param folderIds the folder IDs
2609            * @param start the lower bound of the range of journal articles
2610            * @param end the upper bound of the range of journal articles (not inclusive)
2611            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2612            * @return the ordered range of matching journal articles
2613            * @throws SystemException if a system exception occurred
2614            */
2615            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2616                    long groupId, long[] folderIds, int start, int end,
2617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2618                    throws com.liferay.portal.kernel.exception.SystemException {
2619                    return getPersistence()
2620                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2621            }
2622    
2623            /**
2624            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2625            *
2626            * @param groupId the group ID
2627            * @param folderId the folder ID
2628            * @throws SystemException if a system exception occurred
2629            */
2630            public static void removeByG_F(long groupId, long folderId)
2631                    throws com.liferay.portal.kernel.exception.SystemException {
2632                    getPersistence().removeByG_F(groupId, folderId);
2633            }
2634    
2635            /**
2636            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2637            *
2638            * @param groupId the group ID
2639            * @param folderId the folder ID
2640            * @return the number of matching journal articles
2641            * @throws SystemException if a system exception occurred
2642            */
2643            public static int countByG_F(long groupId, long folderId)
2644                    throws com.liferay.portal.kernel.exception.SystemException {
2645                    return getPersistence().countByG_F(groupId, folderId);
2646            }
2647    
2648            /**
2649            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2650            *
2651            * @param groupId the group ID
2652            * @param folderIds the folder IDs
2653            * @return the number of matching journal articles
2654            * @throws SystemException if a system exception occurred
2655            */
2656            public static int countByG_F(long groupId, long[] folderIds)
2657                    throws com.liferay.portal.kernel.exception.SystemException {
2658                    return getPersistence().countByG_F(groupId, folderIds);
2659            }
2660    
2661            /**
2662            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2663            *
2664            * @param groupId the group ID
2665            * @param folderId the folder ID
2666            * @return the number of matching journal articles that the user has permission to view
2667            * @throws SystemException if a system exception occurred
2668            */
2669            public static int filterCountByG_F(long groupId, long folderId)
2670                    throws com.liferay.portal.kernel.exception.SystemException {
2671                    return getPersistence().filterCountByG_F(groupId, folderId);
2672            }
2673    
2674            /**
2675            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2676            *
2677            * @param groupId the group ID
2678            * @param folderIds the folder IDs
2679            * @return the number of matching journal articles that the user has permission to view
2680            * @throws SystemException if a system exception occurred
2681            */
2682            public static int filterCountByG_F(long groupId, long[] folderIds)
2683                    throws com.liferay.portal.kernel.exception.SystemException {
2684                    return getPersistence().filterCountByG_F(groupId, folderIds);
2685            }
2686    
2687            /**
2688            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2689            *
2690            * @param groupId the group ID
2691            * @param articleId the article ID
2692            * @return the matching journal articles
2693            * @throws SystemException if a system exception occurred
2694            */
2695            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2696                    long groupId, java.lang.String articleId)
2697                    throws com.liferay.portal.kernel.exception.SystemException {
2698                    return getPersistence().findByG_A(groupId, articleId);
2699            }
2700    
2701            /**
2702            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2703            *
2704            * <p>
2705            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2706            * </p>
2707            *
2708            * @param groupId the group ID
2709            * @param articleId the article ID
2710            * @param start the lower bound of the range of journal articles
2711            * @param end the upper bound of the range of journal articles (not inclusive)
2712            * @return the range of matching journal articles
2713            * @throws SystemException if a system exception occurred
2714            */
2715            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2716                    long groupId, java.lang.String articleId, int start, int end)
2717                    throws com.liferay.portal.kernel.exception.SystemException {
2718                    return getPersistence().findByG_A(groupId, articleId, start, end);
2719            }
2720    
2721            /**
2722            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2723            *
2724            * <p>
2725            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2726            * </p>
2727            *
2728            * @param groupId the group ID
2729            * @param articleId the article ID
2730            * @param start the lower bound of the range of journal articles
2731            * @param end the upper bound of the range of journal articles (not inclusive)
2732            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2733            * @return the ordered range of matching journal articles
2734            * @throws SystemException if a system exception occurred
2735            */
2736            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2737                    long groupId, java.lang.String articleId, int start, int end,
2738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2739                    throws com.liferay.portal.kernel.exception.SystemException {
2740                    return getPersistence()
2741                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2742            }
2743    
2744            /**
2745            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2746            *
2747            * @param groupId the group ID
2748            * @param articleId the article ID
2749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2750            * @return the first matching journal article
2751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2752            * @throws SystemException if a system exception occurred
2753            */
2754            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
2755                    long groupId, java.lang.String articleId,
2756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2757                    throws com.liferay.portal.kernel.exception.SystemException,
2758                            com.liferay.portlet.journal.NoSuchArticleException {
2759                    return getPersistence()
2760                                       .findByG_A_First(groupId, articleId, orderByComparator);
2761            }
2762    
2763            /**
2764            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2765            *
2766            * @param groupId the group ID
2767            * @param articleId the article ID
2768            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2769            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2770            * @throws SystemException if a system exception occurred
2771            */
2772            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First(
2773                    long groupId, java.lang.String articleId,
2774                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2775                    throws com.liferay.portal.kernel.exception.SystemException {
2776                    return getPersistence()
2777                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
2778            }
2779    
2780            /**
2781            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2782            *
2783            * @param groupId the group ID
2784            * @param articleId the article ID
2785            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2786            * @return the last matching journal article
2787            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2788            * @throws SystemException if a system exception occurred
2789            */
2790            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
2791                    long groupId, java.lang.String articleId,
2792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2793                    throws com.liferay.portal.kernel.exception.SystemException,
2794                            com.liferay.portlet.journal.NoSuchArticleException {
2795                    return getPersistence()
2796                                       .findByG_A_Last(groupId, articleId, orderByComparator);
2797            }
2798    
2799            /**
2800            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2801            *
2802            * @param groupId the group ID
2803            * @param articleId the article ID
2804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2805            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2806            * @throws SystemException if a system exception occurred
2807            */
2808            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
2809                    long groupId, java.lang.String articleId,
2810                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2811                    throws com.liferay.portal.kernel.exception.SystemException {
2812                    return getPersistence()
2813                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
2814            }
2815    
2816            /**
2817            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2818            *
2819            * @param id the primary key of the current journal article
2820            * @param groupId the group ID
2821            * @param articleId the article ID
2822            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2823            * @return the previous, current, and next journal article
2824            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2825            * @throws SystemException if a system exception occurred
2826            */
2827            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
2828                    long id, long groupId, java.lang.String articleId,
2829                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2830                    throws com.liferay.portal.kernel.exception.SystemException,
2831                            com.liferay.portlet.journal.NoSuchArticleException {
2832                    return getPersistence()
2833                                       .findByG_A_PrevAndNext(id, groupId, articleId,
2834                            orderByComparator);
2835            }
2836    
2837            /**
2838            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2839            *
2840            * @param groupId the group ID
2841            * @param articleId the article ID
2842            * @return the matching journal articles that the user has permission to view
2843            * @throws SystemException if a system exception occurred
2844            */
2845            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2846                    long groupId, java.lang.String articleId)
2847                    throws com.liferay.portal.kernel.exception.SystemException {
2848                    return getPersistence().filterFindByG_A(groupId, articleId);
2849            }
2850    
2851            /**
2852            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2853            *
2854            * <p>
2855            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2856            * </p>
2857            *
2858            * @param groupId the group ID
2859            * @param articleId the article ID
2860            * @param start the lower bound of the range of journal articles
2861            * @param end the upper bound of the range of journal articles (not inclusive)
2862            * @return the range of matching journal articles that the user has permission to view
2863            * @throws SystemException if a system exception occurred
2864            */
2865            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2866                    long groupId, java.lang.String articleId, int start, int end)
2867                    throws com.liferay.portal.kernel.exception.SystemException {
2868                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
2869            }
2870    
2871            /**
2872            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
2873            *
2874            * <p>
2875            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2876            * </p>
2877            *
2878            * @param groupId the group ID
2879            * @param articleId the article ID
2880            * @param start the lower bound of the range of journal articles
2881            * @param end the upper bound of the range of journal articles (not inclusive)
2882            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2883            * @return the ordered range of matching journal articles that the user has permission to view
2884            * @throws SystemException if a system exception occurred
2885            */
2886            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2887                    long groupId, java.lang.String articleId, int start, int end,
2888                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2889                    throws com.liferay.portal.kernel.exception.SystemException {
2890                    return getPersistence()
2891                                       .filterFindByG_A(groupId, articleId, start, end,
2892                            orderByComparator);
2893            }
2894    
2895            /**
2896            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2897            *
2898            * @param id the primary key of the current journal article
2899            * @param groupId the group ID
2900            * @param articleId the article ID
2901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2902            * @return the previous, current, and next journal article
2903            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2904            * @throws SystemException if a system exception occurred
2905            */
2906            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
2907                    long id, long groupId, java.lang.String articleId,
2908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2909                    throws com.liferay.portal.kernel.exception.SystemException,
2910                            com.liferay.portlet.journal.NoSuchArticleException {
2911                    return getPersistence()
2912                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
2913                            orderByComparator);
2914            }
2915    
2916            /**
2917            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2918            *
2919            * @param groupId the group ID
2920            * @param articleId the article ID
2921            * @throws SystemException if a system exception occurred
2922            */
2923            public static void removeByG_A(long groupId, java.lang.String articleId)
2924                    throws com.liferay.portal.kernel.exception.SystemException {
2925                    getPersistence().removeByG_A(groupId, articleId);
2926            }
2927    
2928            /**
2929            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
2930            *
2931            * @param groupId the group ID
2932            * @param articleId the article ID
2933            * @return the number of matching journal articles
2934            * @throws SystemException if a system exception occurred
2935            */
2936            public static int countByG_A(long groupId, java.lang.String articleId)
2937                    throws com.liferay.portal.kernel.exception.SystemException {
2938                    return getPersistence().countByG_A(groupId, articleId);
2939            }
2940    
2941            /**
2942            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2943            *
2944            * @param groupId the group ID
2945            * @param articleId the article ID
2946            * @return the number of matching journal articles that the user has permission to view
2947            * @throws SystemException if a system exception occurred
2948            */
2949            public static int filterCountByG_A(long groupId, java.lang.String articleId)
2950                    throws com.liferay.portal.kernel.exception.SystemException {
2951                    return getPersistence().filterCountByG_A(groupId, articleId);
2952            }
2953    
2954            /**
2955            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
2956            *
2957            * @param groupId the group ID
2958            * @param urlTitle the url title
2959            * @return the matching journal articles
2960            * @throws SystemException if a system exception occurred
2961            */
2962            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2963                    long groupId, java.lang.String urlTitle)
2964                    throws com.liferay.portal.kernel.exception.SystemException {
2965                    return getPersistence().findByG_UT(groupId, urlTitle);
2966            }
2967    
2968            /**
2969            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2970            *
2971            * <p>
2972            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2973            * </p>
2974            *
2975            * @param groupId the group ID
2976            * @param urlTitle the url title
2977            * @param start the lower bound of the range of journal articles
2978            * @param end the upper bound of the range of journal articles (not inclusive)
2979            * @return the range of matching journal articles
2980            * @throws SystemException if a system exception occurred
2981            */
2982            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2983                    long groupId, java.lang.String urlTitle, int start, int end)
2984                    throws com.liferay.portal.kernel.exception.SystemException {
2985                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
2986            }
2987    
2988            /**
2989            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2990            *
2991            * <p>
2992            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2993            * </p>
2994            *
2995            * @param groupId the group ID
2996            * @param urlTitle the url title
2997            * @param start the lower bound of the range of journal articles
2998            * @param end the upper bound of the range of journal articles (not inclusive)
2999            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3000            * @return the ordered range of matching journal articles
3001            * @throws SystemException if a system exception occurred
3002            */
3003            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
3004                    long groupId, java.lang.String urlTitle, int start, int end,
3005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3006                    throws com.liferay.portal.kernel.exception.SystemException {
3007                    return getPersistence()
3008                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
3009            }
3010    
3011            /**
3012            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3013            *
3014            * @param groupId the group ID
3015            * @param urlTitle the url title
3016            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3017            * @return the first matching journal article
3018            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3019            * @throws SystemException if a system exception occurred
3020            */
3021            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
3022                    long groupId, java.lang.String urlTitle,
3023                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3024                    throws com.liferay.portal.kernel.exception.SystemException,
3025                            com.liferay.portlet.journal.NoSuchArticleException {
3026                    return getPersistence()
3027                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
3028            }
3029    
3030            /**
3031            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3032            *
3033            * @param groupId the group ID
3034            * @param urlTitle the url title
3035            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3036            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3037            * @throws SystemException if a system exception occurred
3038            */
3039            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
3040                    long groupId, java.lang.String urlTitle,
3041                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3042                    throws com.liferay.portal.kernel.exception.SystemException {
3043                    return getPersistence()
3044                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
3045            }
3046    
3047            /**
3048            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3049            *
3050            * @param groupId the group ID
3051            * @param urlTitle the url title
3052            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3053            * @return the last matching journal article
3054            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3055            * @throws SystemException if a system exception occurred
3056            */
3057            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
3058                    long groupId, java.lang.String urlTitle,
3059                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3060                    throws com.liferay.portal.kernel.exception.SystemException,
3061                            com.liferay.portlet.journal.NoSuchArticleException {
3062                    return getPersistence()
3063                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
3064            }
3065    
3066            /**
3067            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3068            *
3069            * @param groupId the group ID
3070            * @param urlTitle the url title
3071            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3072            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3073            * @throws SystemException if a system exception occurred
3074            */
3075            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
3076                    long groupId, java.lang.String urlTitle,
3077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3078                    throws com.liferay.portal.kernel.exception.SystemException {
3079                    return getPersistence()
3080                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
3081            }
3082    
3083            /**
3084            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
3085            *
3086            * @param id the primary key of the current journal article
3087            * @param groupId the group ID
3088            * @param urlTitle the url title
3089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3090            * @return the previous, current, and next journal article
3091            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3092            * @throws SystemException if a system exception occurred
3093            */
3094            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
3095                    long id, long groupId, java.lang.String urlTitle,
3096                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3097                    throws com.liferay.portal.kernel.exception.SystemException,
3098                            com.liferay.portlet.journal.NoSuchArticleException {
3099                    return getPersistence()
3100                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
3101                            orderByComparator);
3102            }
3103    
3104            /**
3105            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3106            *
3107            * @param groupId the group ID
3108            * @param urlTitle the url title
3109            * @return the matching journal articles that the user has permission to view
3110            * @throws SystemException if a system exception occurred
3111            */
3112            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3113                    long groupId, java.lang.String urlTitle)
3114                    throws com.liferay.portal.kernel.exception.SystemException {
3115                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
3116            }
3117    
3118            /**
3119            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3120            *
3121            * <p>
3122            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3123            * </p>
3124            *
3125            * @param groupId the group ID
3126            * @param urlTitle the url title
3127            * @param start the lower bound of the range of journal articles
3128            * @param end the upper bound of the range of journal articles (not inclusive)
3129            * @return the range of matching journal articles that the user has permission to view
3130            * @throws SystemException if a system exception occurred
3131            */
3132            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3133                    long groupId, java.lang.String urlTitle, int start, int end)
3134                    throws com.liferay.portal.kernel.exception.SystemException {
3135                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
3136            }
3137    
3138            /**
3139            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
3140            *
3141            * <p>
3142            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3143            * </p>
3144            *
3145            * @param groupId the group ID
3146            * @param urlTitle the url title
3147            * @param start the lower bound of the range of journal articles
3148            * @param end the upper bound of the range of journal articles (not inclusive)
3149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3150            * @return the ordered range of matching journal articles that the user has permission to view
3151            * @throws SystemException if a system exception occurred
3152            */
3153            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3154                    long groupId, java.lang.String urlTitle, int start, int end,
3155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3156                    throws com.liferay.portal.kernel.exception.SystemException {
3157                    return getPersistence()
3158                                       .filterFindByG_UT(groupId, urlTitle, start, end,
3159                            orderByComparator);
3160            }
3161    
3162            /**
3163            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3164            *
3165            * @param id the primary key of the current journal article
3166            * @param groupId the group ID
3167            * @param urlTitle the url title
3168            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3169            * @return the previous, current, and next journal article
3170            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3171            * @throws SystemException if a system exception occurred
3172            */
3173            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
3174                    long id, long groupId, java.lang.String urlTitle,
3175                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3176                    throws com.liferay.portal.kernel.exception.SystemException,
3177                            com.liferay.portlet.journal.NoSuchArticleException {
3178                    return getPersistence()
3179                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
3180                            orderByComparator);
3181            }
3182    
3183            /**
3184            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3185            *
3186            * @param groupId the group ID
3187            * @param urlTitle the url title
3188            * @throws SystemException if a system exception occurred
3189            */
3190            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
3191                    throws com.liferay.portal.kernel.exception.SystemException {
3192                    getPersistence().removeByG_UT(groupId, urlTitle);
3193            }
3194    
3195            /**
3196            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3197            *
3198            * @param groupId the group ID
3199            * @param urlTitle the url title
3200            * @return the number of matching journal articles
3201            * @throws SystemException if a system exception occurred
3202            */
3203            public static int countByG_UT(long groupId, java.lang.String urlTitle)
3204                    throws com.liferay.portal.kernel.exception.SystemException {
3205                    return getPersistence().countByG_UT(groupId, urlTitle);
3206            }
3207    
3208            /**
3209            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3210            *
3211            * @param groupId the group ID
3212            * @param urlTitle the url title
3213            * @return the number of matching journal articles that the user has permission to view
3214            * @throws SystemException if a system exception occurred
3215            */
3216            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
3217                    throws com.liferay.portal.kernel.exception.SystemException {
3218                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3219            }
3220    
3221            /**
3222            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
3223            *
3224            * @param groupId the group ID
3225            * @param structureId the structure ID
3226            * @return the matching journal articles
3227            * @throws SystemException if a system exception occurred
3228            */
3229            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3230                    long groupId, java.lang.String structureId)
3231                    throws com.liferay.portal.kernel.exception.SystemException {
3232                    return getPersistence().findByG_S(groupId, structureId);
3233            }
3234    
3235            /**
3236            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
3237            *
3238            * <p>
3239            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3240            * </p>
3241            *
3242            * @param groupId the group ID
3243            * @param structureId the structure ID
3244            * @param start the lower bound of the range of journal articles
3245            * @param end the upper bound of the range of journal articles (not inclusive)
3246            * @return the range of matching journal articles
3247            * @throws SystemException if a system exception occurred
3248            */
3249            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3250                    long groupId, java.lang.String structureId, int start, int end)
3251                    throws com.liferay.portal.kernel.exception.SystemException {
3252                    return getPersistence().findByG_S(groupId, structureId, start, end);
3253            }
3254    
3255            /**
3256            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
3257            *
3258            * <p>
3259            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3260            * </p>
3261            *
3262            * @param groupId the group ID
3263            * @param structureId the structure ID
3264            * @param start the lower bound of the range of journal articles
3265            * @param end the upper bound of the range of journal articles (not inclusive)
3266            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3267            * @return the ordered range of matching journal articles
3268            * @throws SystemException if a system exception occurred
3269            */
3270            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3271                    long groupId, java.lang.String structureId, int start, int end,
3272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3273                    throws com.liferay.portal.kernel.exception.SystemException {
3274                    return getPersistence()
3275                                       .findByG_S(groupId, structureId, start, end,
3276                            orderByComparator);
3277            }
3278    
3279            /**
3280            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3281            *
3282            * @param groupId the group ID
3283            * @param structureId the structure ID
3284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3285            * @return the first matching journal article
3286            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3287            * @throws SystemException if a system exception occurred
3288            */
3289            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
3290                    long groupId, java.lang.String structureId,
3291                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3292                    throws com.liferay.portal.kernel.exception.SystemException,
3293                            com.liferay.portlet.journal.NoSuchArticleException {
3294                    return getPersistence()
3295                                       .findByG_S_First(groupId, structureId, orderByComparator);
3296            }
3297    
3298            /**
3299            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3300            *
3301            * @param groupId the group ID
3302            * @param structureId the structure ID
3303            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3304            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3305            * @throws SystemException if a system exception occurred
3306            */
3307            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
3308                    long groupId, java.lang.String structureId,
3309                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3310                    throws com.liferay.portal.kernel.exception.SystemException {
3311                    return getPersistence()
3312                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
3313            }
3314    
3315            /**
3316            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3317            *
3318            * @param groupId the group ID
3319            * @param structureId the structure ID
3320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3321            * @return the last matching journal article
3322            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3323            * @throws SystemException if a system exception occurred
3324            */
3325            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
3326                    long groupId, java.lang.String structureId,
3327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3328                    throws com.liferay.portal.kernel.exception.SystemException,
3329                            com.liferay.portlet.journal.NoSuchArticleException {
3330                    return getPersistence()
3331                                       .findByG_S_Last(groupId, structureId, orderByComparator);
3332            }
3333    
3334            /**
3335            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3336            *
3337            * @param groupId the group ID
3338            * @param structureId the structure ID
3339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3340            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3341            * @throws SystemException if a system exception occurred
3342            */
3343            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
3344                    long groupId, java.lang.String structureId,
3345                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3346                    throws com.liferay.portal.kernel.exception.SystemException {
3347                    return getPersistence()
3348                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
3349            }
3350    
3351            /**
3352            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3353            *
3354            * @param id the primary key of the current journal article
3355            * @param groupId the group ID
3356            * @param structureId the structure ID
3357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3358            * @return the previous, current, and next journal article
3359            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3360            * @throws SystemException if a system exception occurred
3361            */
3362            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
3363                    long id, long groupId, java.lang.String structureId,
3364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3365                    throws com.liferay.portal.kernel.exception.SystemException,
3366                            com.liferay.portlet.journal.NoSuchArticleException {
3367                    return getPersistence()
3368                                       .findByG_S_PrevAndNext(id, groupId, structureId,
3369                            orderByComparator);
3370            }
3371    
3372            /**
3373            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3374            *
3375            * @param groupId the group ID
3376            * @param structureId the structure ID
3377            * @return the matching journal articles that the user has permission to view
3378            * @throws SystemException if a system exception occurred
3379            */
3380            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3381                    long groupId, java.lang.String structureId)
3382                    throws com.liferay.portal.kernel.exception.SystemException {
3383                    return getPersistence().filterFindByG_S(groupId, structureId);
3384            }
3385    
3386            /**
3387            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3388            *
3389            * <p>
3390            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3391            * </p>
3392            *
3393            * @param groupId the group ID
3394            * @param structureId the structure ID
3395            * @param start the lower bound of the range of journal articles
3396            * @param end the upper bound of the range of journal articles (not inclusive)
3397            * @return the range of matching journal articles that the user has permission to view
3398            * @throws SystemException if a system exception occurred
3399            */
3400            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3401                    long groupId, java.lang.String structureId, int start, int end)
3402                    throws com.liferay.portal.kernel.exception.SystemException {
3403                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
3404            }
3405    
3406            /**
3407            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
3408            *
3409            * <p>
3410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3411            * </p>
3412            *
3413            * @param groupId the group ID
3414            * @param structureId the structure ID
3415            * @param start the lower bound of the range of journal articles
3416            * @param end the upper bound of the range of journal articles (not inclusive)
3417            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3418            * @return the ordered range of matching journal articles that the user has permission to view
3419            * @throws SystemException if a system exception occurred
3420            */
3421            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3422                    long groupId, java.lang.String structureId, int start, int end,
3423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3424                    throws com.liferay.portal.kernel.exception.SystemException {
3425                    return getPersistence()
3426                                       .filterFindByG_S(groupId, structureId, start, end,
3427                            orderByComparator);
3428            }
3429    
3430            /**
3431            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3432            *
3433            * @param id the primary key of the current journal article
3434            * @param groupId the group ID
3435            * @param structureId the structure ID
3436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3437            * @return the previous, current, and next journal article
3438            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3439            * @throws SystemException if a system exception occurred
3440            */
3441            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
3442                    long id, long groupId, java.lang.String structureId,
3443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3444                    throws com.liferay.portal.kernel.exception.SystemException,
3445                            com.liferay.portlet.journal.NoSuchArticleException {
3446                    return getPersistence()
3447                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
3448                            orderByComparator);
3449            }
3450    
3451            /**
3452            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
3453            *
3454            * @param groupId the group ID
3455            * @param structureId the structure ID
3456            * @throws SystemException if a system exception occurred
3457            */
3458            public static void removeByG_S(long groupId, java.lang.String structureId)
3459                    throws com.liferay.portal.kernel.exception.SystemException {
3460                    getPersistence().removeByG_S(groupId, structureId);
3461            }
3462    
3463            /**
3464            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
3465            *
3466            * @param groupId the group ID
3467            * @param structureId the structure ID
3468            * @return the number of matching journal articles
3469            * @throws SystemException if a system exception occurred
3470            */
3471            public static int countByG_S(long groupId, java.lang.String structureId)
3472                    throws com.liferay.portal.kernel.exception.SystemException {
3473                    return getPersistence().countByG_S(groupId, structureId);
3474            }
3475    
3476            /**
3477            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3478            *
3479            * @param groupId the group ID
3480            * @param structureId the structure ID
3481            * @return the number of matching journal articles that the user has permission to view
3482            * @throws SystemException if a system exception occurred
3483            */
3484            public static int filterCountByG_S(long groupId,
3485                    java.lang.String structureId)
3486                    throws com.liferay.portal.kernel.exception.SystemException {
3487                    return getPersistence().filterCountByG_S(groupId, structureId);
3488            }
3489    
3490            /**
3491            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
3492            *
3493            * @param groupId the group ID
3494            * @param templateId the template ID
3495            * @return the matching journal articles
3496            * @throws SystemException if a system exception occurred
3497            */
3498            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3499                    long groupId, java.lang.String templateId)
3500                    throws com.liferay.portal.kernel.exception.SystemException {
3501                    return getPersistence().findByG_T(groupId, templateId);
3502            }
3503    
3504            /**
3505            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
3506            *
3507            * <p>
3508            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3509            * </p>
3510            *
3511            * @param groupId the group ID
3512            * @param templateId the template ID
3513            * @param start the lower bound of the range of journal articles
3514            * @param end the upper bound of the range of journal articles (not inclusive)
3515            * @return the range of matching journal articles
3516            * @throws SystemException if a system exception occurred
3517            */
3518            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3519                    long groupId, java.lang.String templateId, int start, int end)
3520                    throws com.liferay.portal.kernel.exception.SystemException {
3521                    return getPersistence().findByG_T(groupId, templateId, start, end);
3522            }
3523    
3524            /**
3525            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
3526            *
3527            * <p>
3528            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3529            * </p>
3530            *
3531            * @param groupId the group ID
3532            * @param templateId the template ID
3533            * @param start the lower bound of the range of journal articles
3534            * @param end the upper bound of the range of journal articles (not inclusive)
3535            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3536            * @return the ordered range of matching journal articles
3537            * @throws SystemException if a system exception occurred
3538            */
3539            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3540                    long groupId, java.lang.String templateId, int start, int end,
3541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3542                    throws com.liferay.portal.kernel.exception.SystemException {
3543                    return getPersistence()
3544                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
3545            }
3546    
3547            /**
3548            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3549            *
3550            * @param groupId the group ID
3551            * @param templateId the template ID
3552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3553            * @return the first matching journal article
3554            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3555            * @throws SystemException if a system exception occurred
3556            */
3557            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
3558                    long groupId, java.lang.String templateId,
3559                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3560                    throws com.liferay.portal.kernel.exception.SystemException,
3561                            com.liferay.portlet.journal.NoSuchArticleException {
3562                    return getPersistence()
3563                                       .findByG_T_First(groupId, templateId, orderByComparator);
3564            }
3565    
3566            /**
3567            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3568            *
3569            * @param groupId the group ID
3570            * @param templateId the template ID
3571            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3572            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3573            * @throws SystemException if a system exception occurred
3574            */
3575            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
3576                    long groupId, java.lang.String templateId,
3577                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3578                    throws com.liferay.portal.kernel.exception.SystemException {
3579                    return getPersistence()
3580                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
3581            }
3582    
3583            /**
3584            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3585            *
3586            * @param groupId the group ID
3587            * @param templateId the template ID
3588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3589            * @return the last matching journal article
3590            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3591            * @throws SystemException if a system exception occurred
3592            */
3593            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
3594                    long groupId, java.lang.String templateId,
3595                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3596                    throws com.liferay.portal.kernel.exception.SystemException,
3597                            com.liferay.portlet.journal.NoSuchArticleException {
3598                    return getPersistence()
3599                                       .findByG_T_Last(groupId, templateId, orderByComparator);
3600            }
3601    
3602            /**
3603            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3604            *
3605            * @param groupId the group ID
3606            * @param templateId the template ID
3607            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3608            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3609            * @throws SystemException if a system exception occurred
3610            */
3611            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last(
3612                    long groupId, java.lang.String templateId,
3613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3614                    throws com.liferay.portal.kernel.exception.SystemException {
3615                    return getPersistence()
3616                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
3617            }
3618    
3619            /**
3620            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3621            *
3622            * @param id the primary key of the current journal article
3623            * @param groupId the group ID
3624            * @param templateId the template ID
3625            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3626            * @return the previous, current, and next journal article
3627            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3628            * @throws SystemException if a system exception occurred
3629            */
3630            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
3631                    long id, long groupId, java.lang.String templateId,
3632                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3633                    throws com.liferay.portal.kernel.exception.SystemException,
3634                            com.liferay.portlet.journal.NoSuchArticleException {
3635                    return getPersistence()
3636                                       .findByG_T_PrevAndNext(id, groupId, templateId,
3637                            orderByComparator);
3638            }
3639    
3640            /**
3641            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3642            *
3643            * @param groupId the group ID
3644            * @param templateId the template ID
3645            * @return the matching journal articles that the user has permission to view
3646            * @throws SystemException if a system exception occurred
3647            */
3648            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3649                    long groupId, java.lang.String templateId)
3650                    throws com.liferay.portal.kernel.exception.SystemException {
3651                    return getPersistence().filterFindByG_T(groupId, templateId);
3652            }
3653    
3654            /**
3655            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3656            *
3657            * <p>
3658            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3659            * </p>
3660            *
3661            * @param groupId the group ID
3662            * @param templateId the template ID
3663            * @param start the lower bound of the range of journal articles
3664            * @param end the upper bound of the range of journal articles (not inclusive)
3665            * @return the range of matching journal articles that the user has permission to view
3666            * @throws SystemException if a system exception occurred
3667            */
3668            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3669                    long groupId, java.lang.String templateId, int start, int end)
3670                    throws com.liferay.portal.kernel.exception.SystemException {
3671                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
3672            }
3673    
3674            /**
3675            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
3676            *
3677            * <p>
3678            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3679            * </p>
3680            *
3681            * @param groupId the group ID
3682            * @param templateId the template ID
3683            * @param start the lower bound of the range of journal articles
3684            * @param end the upper bound of the range of journal articles (not inclusive)
3685            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3686            * @return the ordered range of matching journal articles that the user has permission to view
3687            * @throws SystemException if a system exception occurred
3688            */
3689            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3690                    long groupId, java.lang.String templateId, int start, int end,
3691                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3692                    throws com.liferay.portal.kernel.exception.SystemException {
3693                    return getPersistence()
3694                                       .filterFindByG_T(groupId, templateId, start, end,
3695                            orderByComparator);
3696            }
3697    
3698            /**
3699            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3700            *
3701            * @param id the primary key of the current journal article
3702            * @param groupId the group ID
3703            * @param templateId the template ID
3704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3705            * @return the previous, current, and next journal article
3706            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3707            * @throws SystemException if a system exception occurred
3708            */
3709            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
3710                    long id, long groupId, java.lang.String templateId,
3711                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3712                    throws com.liferay.portal.kernel.exception.SystemException,
3713                            com.liferay.portlet.journal.NoSuchArticleException {
3714                    return getPersistence()
3715                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
3716                            orderByComparator);
3717            }
3718    
3719            /**
3720            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
3721            *
3722            * @param groupId the group ID
3723            * @param templateId the template ID
3724            * @throws SystemException if a system exception occurred
3725            */
3726            public static void removeByG_T(long groupId, java.lang.String templateId)
3727                    throws com.liferay.portal.kernel.exception.SystemException {
3728                    getPersistence().removeByG_T(groupId, templateId);
3729            }
3730    
3731            /**
3732            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
3733            *
3734            * @param groupId the group ID
3735            * @param templateId the template ID
3736            * @return the number of matching journal articles
3737            * @throws SystemException if a system exception occurred
3738            */
3739            public static int countByG_T(long groupId, java.lang.String templateId)
3740                    throws com.liferay.portal.kernel.exception.SystemException {
3741                    return getPersistence().countByG_T(groupId, templateId);
3742            }
3743    
3744            /**
3745            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3746            *
3747            * @param groupId the group ID
3748            * @param templateId the template ID
3749            * @return the number of matching journal articles that the user has permission to view
3750            * @throws SystemException if a system exception occurred
3751            */
3752            public static int filterCountByG_T(long groupId, java.lang.String templateId)
3753                    throws com.liferay.portal.kernel.exception.SystemException {
3754                    return getPersistence().filterCountByG_T(groupId, templateId);
3755            }
3756    
3757            /**
3758            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3759            *
3760            * @param groupId the group ID
3761            * @param layoutUuid the layout uuid
3762            * @return the matching journal articles
3763            * @throws SystemException if a system exception occurred
3764            */
3765            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3766                    long groupId, java.lang.String layoutUuid)
3767                    throws com.liferay.portal.kernel.exception.SystemException {
3768                    return getPersistence().findByG_L(groupId, layoutUuid);
3769            }
3770    
3771            /**
3772            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3773            *
3774            * <p>
3775            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3776            * </p>
3777            *
3778            * @param groupId the group ID
3779            * @param layoutUuid the layout uuid
3780            * @param start the lower bound of the range of journal articles
3781            * @param end the upper bound of the range of journal articles (not inclusive)
3782            * @return the range of matching journal articles
3783            * @throws SystemException if a system exception occurred
3784            */
3785            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3786                    long groupId, java.lang.String layoutUuid, int start, int end)
3787                    throws com.liferay.portal.kernel.exception.SystemException {
3788                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
3789            }
3790    
3791            /**
3792            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3793            *
3794            * <p>
3795            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3796            * </p>
3797            *
3798            * @param groupId the group ID
3799            * @param layoutUuid the layout uuid
3800            * @param start the lower bound of the range of journal articles
3801            * @param end the upper bound of the range of journal articles (not inclusive)
3802            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3803            * @return the ordered range of matching journal articles
3804            * @throws SystemException if a system exception occurred
3805            */
3806            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3807                    long groupId, java.lang.String layoutUuid, int start, int end,
3808                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3809                    throws com.liferay.portal.kernel.exception.SystemException {
3810                    return getPersistence()
3811                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
3812            }
3813    
3814            /**
3815            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3816            *
3817            * @param groupId the group ID
3818            * @param layoutUuid the layout uuid
3819            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3820            * @return the first matching journal article
3821            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3822            * @throws SystemException if a system exception occurred
3823            */
3824            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
3825                    long groupId, java.lang.String layoutUuid,
3826                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3827                    throws com.liferay.portal.kernel.exception.SystemException,
3828                            com.liferay.portlet.journal.NoSuchArticleException {
3829                    return getPersistence()
3830                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
3831            }
3832    
3833            /**
3834            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3835            *
3836            * @param groupId the group ID
3837            * @param layoutUuid the layout uuid
3838            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3839            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3840            * @throws SystemException if a system exception occurred
3841            */
3842            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
3843                    long groupId, java.lang.String layoutUuid,
3844                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3845                    throws com.liferay.portal.kernel.exception.SystemException {
3846                    return getPersistence()
3847                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
3848            }
3849    
3850            /**
3851            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3852            *
3853            * @param groupId the group ID
3854            * @param layoutUuid the layout uuid
3855            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3856            * @return the last matching journal article
3857            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3858            * @throws SystemException if a system exception occurred
3859            */
3860            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
3861                    long groupId, java.lang.String layoutUuid,
3862                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3863                    throws com.liferay.portal.kernel.exception.SystemException,
3864                            com.liferay.portlet.journal.NoSuchArticleException {
3865                    return getPersistence()
3866                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
3867            }
3868    
3869            /**
3870            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3871            *
3872            * @param groupId the group ID
3873            * @param layoutUuid the layout uuid
3874            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3875            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3876            * @throws SystemException if a system exception occurred
3877            */
3878            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
3879                    long groupId, java.lang.String layoutUuid,
3880                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3881                    throws com.liferay.portal.kernel.exception.SystemException {
3882                    return getPersistence()
3883                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
3884            }
3885    
3886            /**
3887            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3888            *
3889            * @param id the primary key of the current journal article
3890            * @param groupId the group ID
3891            * @param layoutUuid the layout uuid
3892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3893            * @return the previous, current, and next journal article
3894            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3895            * @throws SystemException if a system exception occurred
3896            */
3897            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
3898                    long id, long groupId, java.lang.String layoutUuid,
3899                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3900                    throws com.liferay.portal.kernel.exception.SystemException,
3901                            com.liferay.portlet.journal.NoSuchArticleException {
3902                    return getPersistence()
3903                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
3904                            orderByComparator);
3905            }
3906    
3907            /**
3908            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3909            *
3910            * @param groupId the group ID
3911            * @param layoutUuid the layout uuid
3912            * @return the matching journal articles that the user has permission to view
3913            * @throws SystemException if a system exception occurred
3914            */
3915            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3916                    long groupId, java.lang.String layoutUuid)
3917                    throws com.liferay.portal.kernel.exception.SystemException {
3918                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
3919            }
3920    
3921            /**
3922            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3923            *
3924            * <p>
3925            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3926            * </p>
3927            *
3928            * @param groupId the group ID
3929            * @param layoutUuid the layout uuid
3930            * @param start the lower bound of the range of journal articles
3931            * @param end the upper bound of the range of journal articles (not inclusive)
3932            * @return the range of matching journal articles that the user has permission to view
3933            * @throws SystemException if a system exception occurred
3934            */
3935            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3936                    long groupId, java.lang.String layoutUuid, int start, int end)
3937                    throws com.liferay.portal.kernel.exception.SystemException {
3938                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
3939            }
3940    
3941            /**
3942            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
3943            *
3944            * <p>
3945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3946            * </p>
3947            *
3948            * @param groupId the group ID
3949            * @param layoutUuid the layout uuid
3950            * @param start the lower bound of the range of journal articles
3951            * @param end the upper bound of the range of journal articles (not inclusive)
3952            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3953            * @return the ordered range of matching journal articles that the user has permission to view
3954            * @throws SystemException if a system exception occurred
3955            */
3956            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3957                    long groupId, java.lang.String layoutUuid, int start, int end,
3958                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3959                    throws com.liferay.portal.kernel.exception.SystemException {
3960                    return getPersistence()
3961                                       .filterFindByG_L(groupId, layoutUuid, start, end,
3962                            orderByComparator);
3963            }
3964    
3965            /**
3966            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3967            *
3968            * @param id the primary key of the current journal article
3969            * @param groupId the group ID
3970            * @param layoutUuid the layout uuid
3971            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3972            * @return the previous, current, and next journal article
3973            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3974            * @throws SystemException if a system exception occurred
3975            */
3976            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
3977                    long id, long groupId, java.lang.String layoutUuid,
3978                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3979                    throws com.liferay.portal.kernel.exception.SystemException,
3980                            com.liferay.portlet.journal.NoSuchArticleException {
3981                    return getPersistence()
3982                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
3983                            orderByComparator);
3984            }
3985    
3986            /**
3987            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
3988            *
3989            * @param groupId the group ID
3990            * @param layoutUuid the layout uuid
3991            * @throws SystemException if a system exception occurred
3992            */
3993            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
3994                    throws com.liferay.portal.kernel.exception.SystemException {
3995                    getPersistence().removeByG_L(groupId, layoutUuid);
3996            }
3997    
3998            /**
3999            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4000            *
4001            * @param groupId the group ID
4002            * @param layoutUuid the layout uuid
4003            * @return the number of matching journal articles
4004            * @throws SystemException if a system exception occurred
4005            */
4006            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4007                    throws com.liferay.portal.kernel.exception.SystemException {
4008                    return getPersistence().countByG_L(groupId, layoutUuid);
4009            }
4010    
4011            /**
4012            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4013            *
4014            * @param groupId the group ID
4015            * @param layoutUuid the layout uuid
4016            * @return the number of matching journal articles that the user has permission to view
4017            * @throws SystemException if a system exception occurred
4018            */
4019            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4020                    throws com.liferay.portal.kernel.exception.SystemException {
4021                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4022            }
4023    
4024            /**
4025            * Returns all the journal articles where groupId = &#63; and status = &#63;.
4026            *
4027            * @param groupId the group ID
4028            * @param status the status
4029            * @return the matching journal articles
4030            * @throws SystemException if a system exception occurred
4031            */
4032            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4033                    long groupId, int status)
4034                    throws com.liferay.portal.kernel.exception.SystemException {
4035                    return getPersistence().findByG_ST(groupId, status);
4036            }
4037    
4038            /**
4039            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
4040            *
4041            * <p>
4042            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4043            * </p>
4044            *
4045            * @param groupId the group ID
4046            * @param status the status
4047            * @param start the lower bound of the range of journal articles
4048            * @param end the upper bound of the range of journal articles (not inclusive)
4049            * @return the range of matching journal articles
4050            * @throws SystemException if a system exception occurred
4051            */
4052            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4053                    long groupId, int status, int start, int end)
4054                    throws com.liferay.portal.kernel.exception.SystemException {
4055                    return getPersistence().findByG_ST(groupId, status, start, end);
4056            }
4057    
4058            /**
4059            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
4060            *
4061            * <p>
4062            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4063            * </p>
4064            *
4065            * @param groupId the group ID
4066            * @param status the status
4067            * @param start the lower bound of the range of journal articles
4068            * @param end the upper bound of the range of journal articles (not inclusive)
4069            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4070            * @return the ordered range of matching journal articles
4071            * @throws SystemException if a system exception occurred
4072            */
4073            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
4074                    long groupId, int status, int start, int end,
4075                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4076                    throws com.liferay.portal.kernel.exception.SystemException {
4077                    return getPersistence()
4078                                       .findByG_ST(groupId, status, start, end, orderByComparator);
4079            }
4080    
4081            /**
4082            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4083            *
4084            * @param groupId the group ID
4085            * @param status the status
4086            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4087            * @return the first matching journal article
4088            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4089            * @throws SystemException if a system exception occurred
4090            */
4091            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
4092                    long groupId, int status,
4093                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4094                    throws com.liferay.portal.kernel.exception.SystemException,
4095                            com.liferay.portlet.journal.NoSuchArticleException {
4096                    return getPersistence()
4097                                       .findByG_ST_First(groupId, status, orderByComparator);
4098            }
4099    
4100            /**
4101            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
4102            *
4103            * @param groupId the group ID
4104            * @param status the status
4105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4106            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4107            * @throws SystemException if a system exception occurred
4108            */
4109            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
4110                    long groupId, int status,
4111                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4112                    throws com.liferay.portal.kernel.exception.SystemException {
4113                    return getPersistence()
4114                                       .fetchByG_ST_First(groupId, status, orderByComparator);
4115            }
4116    
4117            /**
4118            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4119            *
4120            * @param groupId the group ID
4121            * @param status the status
4122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4123            * @return the last matching journal article
4124            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4125            * @throws SystemException if a system exception occurred
4126            */
4127            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
4128                    long groupId, int status,
4129                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4130                    throws com.liferay.portal.kernel.exception.SystemException,
4131                            com.liferay.portlet.journal.NoSuchArticleException {
4132                    return getPersistence()
4133                                       .findByG_ST_Last(groupId, status, orderByComparator);
4134            }
4135    
4136            /**
4137            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
4138            *
4139            * @param groupId the group ID
4140            * @param status the status
4141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4142            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4143            * @throws SystemException if a system exception occurred
4144            */
4145            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last(
4146                    long groupId, int status,
4147                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4148                    throws com.liferay.portal.kernel.exception.SystemException {
4149                    return getPersistence()
4150                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
4151            }
4152    
4153            /**
4154            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
4155            *
4156            * @param id the primary key of the current journal article
4157            * @param groupId the group ID
4158            * @param status the status
4159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4160            * @return the previous, current, and next journal article
4161            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4162            * @throws SystemException if a system exception occurred
4163            */
4164            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
4165                    long id, long groupId, int status,
4166                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4167                    throws com.liferay.portal.kernel.exception.SystemException,
4168                            com.liferay.portlet.journal.NoSuchArticleException {
4169                    return getPersistence()
4170                                       .findByG_ST_PrevAndNext(id, groupId, status,
4171                            orderByComparator);
4172            }
4173    
4174            /**
4175            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4176            *
4177            * @param groupId the group ID
4178            * @param status the status
4179            * @return the matching journal articles that the user has permission to view
4180            * @throws SystemException if a system exception occurred
4181            */
4182            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4183                    long groupId, int status)
4184                    throws com.liferay.portal.kernel.exception.SystemException {
4185                    return getPersistence().filterFindByG_ST(groupId, status);
4186            }
4187    
4188            /**
4189            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4190            *
4191            * <p>
4192            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4193            * </p>
4194            *
4195            * @param groupId the group ID
4196            * @param status the status
4197            * @param start the lower bound of the range of journal articles
4198            * @param end the upper bound of the range of journal articles (not inclusive)
4199            * @return the range of matching journal articles that the user has permission to view
4200            * @throws SystemException if a system exception occurred
4201            */
4202            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4203                    long groupId, int status, int start, int end)
4204                    throws com.liferay.portal.kernel.exception.SystemException {
4205                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
4206            }
4207    
4208            /**
4209            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
4210            *
4211            * <p>
4212            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4213            * </p>
4214            *
4215            * @param groupId the group ID
4216            * @param status the status
4217            * @param start the lower bound of the range of journal articles
4218            * @param end the upper bound of the range of journal articles (not inclusive)
4219            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4220            * @return the ordered range of matching journal articles that the user has permission to view
4221            * @throws SystemException if a system exception occurred
4222            */
4223            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
4224                    long groupId, int status, int start, int end,
4225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4226                    throws com.liferay.portal.kernel.exception.SystemException {
4227                    return getPersistence()
4228                                       .filterFindByG_ST(groupId, status, start, end,
4229                            orderByComparator);
4230            }
4231    
4232            /**
4233            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4234            *
4235            * @param id the primary key of the current journal article
4236            * @param groupId the group ID
4237            * @param status the status
4238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4239            * @return the previous, current, and next journal article
4240            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4241            * @throws SystemException if a system exception occurred
4242            */
4243            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
4244                    long id, long groupId, int status,
4245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4246                    throws com.liferay.portal.kernel.exception.SystemException,
4247                            com.liferay.portlet.journal.NoSuchArticleException {
4248                    return getPersistence()
4249                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
4250                            orderByComparator);
4251            }
4252    
4253            /**
4254            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4255            *
4256            * @param groupId the group ID
4257            * @param status the status
4258            * @throws SystemException if a system exception occurred
4259            */
4260            public static void removeByG_ST(long groupId, int status)
4261                    throws com.liferay.portal.kernel.exception.SystemException {
4262                    getPersistence().removeByG_ST(groupId, status);
4263            }
4264    
4265            /**
4266            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4267            *
4268            * @param groupId the group ID
4269            * @param status the status
4270            * @return the number of matching journal articles
4271            * @throws SystemException if a system exception occurred
4272            */
4273            public static int countByG_ST(long groupId, int status)
4274                    throws com.liferay.portal.kernel.exception.SystemException {
4275                    return getPersistence().countByG_ST(groupId, status);
4276            }
4277    
4278            /**
4279            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4280            *
4281            * @param groupId the group ID
4282            * @param status the status
4283            * @return the number of matching journal articles that the user has permission to view
4284            * @throws SystemException if a system exception occurred
4285            */
4286            public static int filterCountByG_ST(long groupId, int status)
4287                    throws com.liferay.portal.kernel.exception.SystemException {
4288                    return getPersistence().filterCountByG_ST(groupId, status);
4289            }
4290    
4291            /**
4292            * Returns all the journal articles where companyId = &#63; and version = &#63;.
4293            *
4294            * @param companyId the company ID
4295            * @param version the version
4296            * @return the matching journal articles
4297            * @throws SystemException if a system exception occurred
4298            */
4299            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4300                    long companyId, double version)
4301                    throws com.liferay.portal.kernel.exception.SystemException {
4302                    return getPersistence().findByC_V(companyId, version);
4303            }
4304    
4305            /**
4306            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4307            *
4308            * <p>
4309            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4310            * </p>
4311            *
4312            * @param companyId the company ID
4313            * @param version the version
4314            * @param start the lower bound of the range of journal articles
4315            * @param end the upper bound of the range of journal articles (not inclusive)
4316            * @return the range of matching journal articles
4317            * @throws SystemException if a system exception occurred
4318            */
4319            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4320                    long companyId, double version, int start, int end)
4321                    throws com.liferay.portal.kernel.exception.SystemException {
4322                    return getPersistence().findByC_V(companyId, version, start, end);
4323            }
4324    
4325            /**
4326            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
4327            *
4328            * <p>
4329            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4330            * </p>
4331            *
4332            * @param companyId the company ID
4333            * @param version the version
4334            * @param start the lower bound of the range of journal articles
4335            * @param end the upper bound of the range of journal articles (not inclusive)
4336            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4337            * @return the ordered range of matching journal articles
4338            * @throws SystemException if a system exception occurred
4339            */
4340            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4341                    long companyId, double version, int start, int end,
4342                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4343                    throws com.liferay.portal.kernel.exception.SystemException {
4344                    return getPersistence()
4345                                       .findByC_V(companyId, version, start, end, orderByComparator);
4346            }
4347    
4348            /**
4349            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4350            *
4351            * @param companyId the company ID
4352            * @param version the version
4353            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4354            * @return the first matching journal article
4355            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4356            * @throws SystemException if a system exception occurred
4357            */
4358            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
4359                    long companyId, double version,
4360                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4361                    throws com.liferay.portal.kernel.exception.SystemException,
4362                            com.liferay.portlet.journal.NoSuchArticleException {
4363                    return getPersistence()
4364                                       .findByC_V_First(companyId, version, orderByComparator);
4365            }
4366    
4367            /**
4368            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4369            *
4370            * @param companyId the company ID
4371            * @param version the version
4372            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4373            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4374            * @throws SystemException if a system exception occurred
4375            */
4376            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
4377                    long companyId, double version,
4378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4379                    throws com.liferay.portal.kernel.exception.SystemException {
4380                    return getPersistence()
4381                                       .fetchByC_V_First(companyId, version, orderByComparator);
4382            }
4383    
4384            /**
4385            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4386            *
4387            * @param companyId the company ID
4388            * @param version the version
4389            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4390            * @return the last matching journal article
4391            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4392            * @throws SystemException if a system exception occurred
4393            */
4394            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
4395                    long companyId, double version,
4396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4397                    throws com.liferay.portal.kernel.exception.SystemException,
4398                            com.liferay.portlet.journal.NoSuchArticleException {
4399                    return getPersistence()
4400                                       .findByC_V_Last(companyId, version, orderByComparator);
4401            }
4402    
4403            /**
4404            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4405            *
4406            * @param companyId the company ID
4407            * @param version the version
4408            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4409            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4410            * @throws SystemException if a system exception occurred
4411            */
4412            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
4413                    long companyId, double version,
4414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4415                    throws com.liferay.portal.kernel.exception.SystemException {
4416                    return getPersistence()
4417                                       .fetchByC_V_Last(companyId, version, orderByComparator);
4418            }
4419    
4420            /**
4421            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
4422            *
4423            * @param id the primary key of the current journal article
4424            * @param companyId the company ID
4425            * @param version the version
4426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4427            * @return the previous, current, and next journal article
4428            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4429            * @throws SystemException if a system exception occurred
4430            */
4431            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
4432                    long id, long companyId, double version,
4433                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4434                    throws com.liferay.portal.kernel.exception.SystemException,
4435                            com.liferay.portlet.journal.NoSuchArticleException {
4436                    return getPersistence()
4437                                       .findByC_V_PrevAndNext(id, companyId, version,
4438                            orderByComparator);
4439            }
4440    
4441            /**
4442            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4443            *
4444            * @param companyId the company ID
4445            * @param version the version
4446            * @throws SystemException if a system exception occurred
4447            */
4448            public static void removeByC_V(long companyId, double version)
4449                    throws com.liferay.portal.kernel.exception.SystemException {
4450                    getPersistence().removeByC_V(companyId, version);
4451            }
4452    
4453            /**
4454            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4455            *
4456            * @param companyId the company ID
4457            * @param version the version
4458            * @return the number of matching journal articles
4459            * @throws SystemException if a system exception occurred
4460            */
4461            public static int countByC_V(long companyId, double version)
4462                    throws com.liferay.portal.kernel.exception.SystemException {
4463                    return getPersistence().countByC_V(companyId, version);
4464            }
4465    
4466            /**
4467            * Returns all the journal articles where companyId = &#63; and status = &#63;.
4468            *
4469            * @param companyId the company ID
4470            * @param status the status
4471            * @return the matching journal articles
4472            * @throws SystemException if a system exception occurred
4473            */
4474            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4475                    long companyId, int status)
4476                    throws com.liferay.portal.kernel.exception.SystemException {
4477                    return getPersistence().findByC_ST(companyId, status);
4478            }
4479    
4480            /**
4481            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
4482            *
4483            * <p>
4484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4485            * </p>
4486            *
4487            * @param companyId the company ID
4488            * @param status the status
4489            * @param start the lower bound of the range of journal articles
4490            * @param end the upper bound of the range of journal articles (not inclusive)
4491            * @return the range of matching journal articles
4492            * @throws SystemException if a system exception occurred
4493            */
4494            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4495                    long companyId, int status, int start, int end)
4496                    throws com.liferay.portal.kernel.exception.SystemException {
4497                    return getPersistence().findByC_ST(companyId, status, start, end);
4498            }
4499    
4500            /**
4501            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
4502            *
4503            * <p>
4504            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4505            * </p>
4506            *
4507            * @param companyId the company ID
4508            * @param status the status
4509            * @param start the lower bound of the range of journal articles
4510            * @param end the upper bound of the range of journal articles (not inclusive)
4511            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4512            * @return the ordered range of matching journal articles
4513            * @throws SystemException if a system exception occurred
4514            */
4515            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4516                    long companyId, int status, int start, int end,
4517                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4518                    throws com.liferay.portal.kernel.exception.SystemException {
4519                    return getPersistence()
4520                                       .findByC_ST(companyId, status, start, end, orderByComparator);
4521            }
4522    
4523            /**
4524            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4525            *
4526            * @param companyId the company ID
4527            * @param status the status
4528            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4529            * @return the first matching journal article
4530            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4531            * @throws SystemException if a system exception occurred
4532            */
4533            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
4534                    long companyId, int status,
4535                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4536                    throws com.liferay.portal.kernel.exception.SystemException,
4537                            com.liferay.portlet.journal.NoSuchArticleException {
4538                    return getPersistence()
4539                                       .findByC_ST_First(companyId, status, orderByComparator);
4540            }
4541    
4542            /**
4543            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4544            *
4545            * @param companyId the company ID
4546            * @param status the status
4547            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4548            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4549            * @throws SystemException if a system exception occurred
4550            */
4551            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
4552                    long companyId, int status,
4553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4554                    throws com.liferay.portal.kernel.exception.SystemException {
4555                    return getPersistence()
4556                                       .fetchByC_ST_First(companyId, status, orderByComparator);
4557            }
4558    
4559            /**
4560            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4561            *
4562            * @param companyId the company ID
4563            * @param status the status
4564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4565            * @return the last matching journal article
4566            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4567            * @throws SystemException if a system exception occurred
4568            */
4569            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
4570                    long companyId, int status,
4571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4572                    throws com.liferay.portal.kernel.exception.SystemException,
4573                            com.liferay.portlet.journal.NoSuchArticleException {
4574                    return getPersistence()
4575                                       .findByC_ST_Last(companyId, status, orderByComparator);
4576            }
4577    
4578            /**
4579            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4580            *
4581            * @param companyId the company ID
4582            * @param status the status
4583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4584            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4585            * @throws SystemException if a system exception occurred
4586            */
4587            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
4588                    long companyId, int status,
4589                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4590                    throws com.liferay.portal.kernel.exception.SystemException {
4591                    return getPersistence()
4592                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
4593            }
4594    
4595            /**
4596            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
4597            *
4598            * @param id the primary key of the current journal article
4599            * @param companyId the company ID
4600            * @param status the status
4601            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4602            * @return the previous, current, and next journal article
4603            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4604            * @throws SystemException if a system exception occurred
4605            */
4606            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
4607                    long id, long companyId, int status,
4608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4609                    throws com.liferay.portal.kernel.exception.SystemException,
4610                            com.liferay.portlet.journal.NoSuchArticleException {
4611                    return getPersistence()
4612                                       .findByC_ST_PrevAndNext(id, companyId, status,
4613                            orderByComparator);
4614            }
4615    
4616            /**
4617            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4618            *
4619            * @param companyId the company ID
4620            * @param status the status
4621            * @throws SystemException if a system exception occurred
4622            */
4623            public static void removeByC_ST(long companyId, int status)
4624                    throws com.liferay.portal.kernel.exception.SystemException {
4625                    getPersistence().removeByC_ST(companyId, status);
4626            }
4627    
4628            /**
4629            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4630            *
4631            * @param companyId the company ID
4632            * @param status the status
4633            * @return the number of matching journal articles
4634            * @throws SystemException if a system exception occurred
4635            */
4636            public static int countByC_ST(long companyId, int status)
4637                    throws com.liferay.portal.kernel.exception.SystemException {
4638                    return getPersistence().countByC_ST(companyId, status);
4639            }
4640    
4641            /**
4642            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4643            *
4644            * @param groupId the group ID
4645            * @param folderId the folder ID
4646            * @param status the status
4647            * @return the matching journal articles
4648            * @throws SystemException if a system exception occurred
4649            */
4650            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4651                    long groupId, long folderId, int status)
4652                    throws com.liferay.portal.kernel.exception.SystemException {
4653                    return getPersistence().findByG_F_ST(groupId, folderId, status);
4654            }
4655    
4656            /**
4657            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4658            *
4659            * <p>
4660            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4661            * </p>
4662            *
4663            * @param groupId the group ID
4664            * @param folderId the folder ID
4665            * @param status the status
4666            * @param start the lower bound of the range of journal articles
4667            * @param end the upper bound of the range of journal articles (not inclusive)
4668            * @return the range of matching journal articles
4669            * @throws SystemException if a system exception occurred
4670            */
4671            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4672                    long groupId, long folderId, int status, int start, int end)
4673                    throws com.liferay.portal.kernel.exception.SystemException {
4674                    return getPersistence()
4675                                       .findByG_F_ST(groupId, folderId, status, start, end);
4676            }
4677    
4678            /**
4679            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4680            *
4681            * <p>
4682            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4683            * </p>
4684            *
4685            * @param groupId the group ID
4686            * @param folderId the folder ID
4687            * @param status the status
4688            * @param start the lower bound of the range of journal articles
4689            * @param end the upper bound of the range of journal articles (not inclusive)
4690            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4691            * @return the ordered range of matching journal articles
4692            * @throws SystemException if a system exception occurred
4693            */
4694            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4695                    long groupId, long folderId, int status, int start, int end,
4696                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4697                    throws com.liferay.portal.kernel.exception.SystemException {
4698                    return getPersistence()
4699                                       .findByG_F_ST(groupId, folderId, status, start, end,
4700                            orderByComparator);
4701            }
4702    
4703            /**
4704            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4705            *
4706            * @param groupId the group ID
4707            * @param folderId the folder ID
4708            * @param status the status
4709            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4710            * @return the first matching journal article
4711            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4712            * @throws SystemException if a system exception occurred
4713            */
4714            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
4715                    long groupId, long folderId, int status,
4716                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4717                    throws com.liferay.portal.kernel.exception.SystemException,
4718                            com.liferay.portlet.journal.NoSuchArticleException {
4719                    return getPersistence()
4720                                       .findByG_F_ST_First(groupId, folderId, status,
4721                            orderByComparator);
4722            }
4723    
4724            /**
4725            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4726            *
4727            * @param groupId the group ID
4728            * @param folderId the folder ID
4729            * @param status the status
4730            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4731            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4732            * @throws SystemException if a system exception occurred
4733            */
4734            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
4735                    long groupId, long folderId, int status,
4736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4737                    throws com.liferay.portal.kernel.exception.SystemException {
4738                    return getPersistence()
4739                                       .fetchByG_F_ST_First(groupId, folderId, status,
4740                            orderByComparator);
4741            }
4742    
4743            /**
4744            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4745            *
4746            * @param groupId the group ID
4747            * @param folderId the folder ID
4748            * @param status the status
4749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4750            * @return the last matching journal article
4751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4752            * @throws SystemException if a system exception occurred
4753            */
4754            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
4755                    long groupId, long folderId, int status,
4756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4757                    throws com.liferay.portal.kernel.exception.SystemException,
4758                            com.liferay.portlet.journal.NoSuchArticleException {
4759                    return getPersistence()
4760                                       .findByG_F_ST_Last(groupId, folderId, status,
4761                            orderByComparator);
4762            }
4763    
4764            /**
4765            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4766            *
4767            * @param groupId the group ID
4768            * @param folderId the folder ID
4769            * @param status the status
4770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4771            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4772            * @throws SystemException if a system exception occurred
4773            */
4774            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
4775                    long groupId, long folderId, int status,
4776                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4777                    throws com.liferay.portal.kernel.exception.SystemException {
4778                    return getPersistence()
4779                                       .fetchByG_F_ST_Last(groupId, folderId, status,
4780                            orderByComparator);
4781            }
4782    
4783            /**
4784            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4785            *
4786            * @param id the primary key of the current journal article
4787            * @param groupId the group ID
4788            * @param folderId the folder ID
4789            * @param status the status
4790            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4791            * @return the previous, current, and next journal article
4792            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4793            * @throws SystemException if a system exception occurred
4794            */
4795            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
4796                    long id, long groupId, long folderId, int status,
4797                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4798                    throws com.liferay.portal.kernel.exception.SystemException,
4799                            com.liferay.portlet.journal.NoSuchArticleException {
4800                    return getPersistence()
4801                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
4802                            orderByComparator);
4803            }
4804    
4805            /**
4806            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4807            *
4808            * @param groupId the group ID
4809            * @param folderId the folder ID
4810            * @param status the status
4811            * @return the matching journal articles that the user has permission to view
4812            * @throws SystemException if a system exception occurred
4813            */
4814            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4815                    long groupId, long folderId, int status)
4816                    throws com.liferay.portal.kernel.exception.SystemException {
4817                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
4818            }
4819    
4820            /**
4821            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4822            *
4823            * <p>
4824            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4825            * </p>
4826            *
4827            * @param groupId the group ID
4828            * @param folderId the folder ID
4829            * @param status the status
4830            * @param start the lower bound of the range of journal articles
4831            * @param end the upper bound of the range of journal articles (not inclusive)
4832            * @return the range of matching journal articles that the user has permission to view
4833            * @throws SystemException if a system exception occurred
4834            */
4835            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4836                    long groupId, long folderId, int status, int start, int end)
4837                    throws com.liferay.portal.kernel.exception.SystemException {
4838                    return getPersistence()
4839                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
4840            }
4841    
4842            /**
4843            * 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;.
4844            *
4845            * <p>
4846            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4847            * </p>
4848            *
4849            * @param groupId the group ID
4850            * @param folderId the folder ID
4851            * @param status the status
4852            * @param start the lower bound of the range of journal articles
4853            * @param end the upper bound of the range of journal articles (not inclusive)
4854            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4855            * @return the ordered range of matching journal articles that the user has permission to view
4856            * @throws SystemException if a system exception occurred
4857            */
4858            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4859                    long groupId, long folderId, int status, int start, int end,
4860                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4861                    throws com.liferay.portal.kernel.exception.SystemException {
4862                    return getPersistence()
4863                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
4864                            orderByComparator);
4865            }
4866    
4867            /**
4868            * 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;.
4869            *
4870            * @param id the primary key of the current journal article
4871            * @param groupId the group ID
4872            * @param folderId the folder ID
4873            * @param status the status
4874            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4875            * @return the previous, current, and next journal article
4876            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4877            * @throws SystemException if a system exception occurred
4878            */
4879            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
4880                    long id, long groupId, long folderId, int status,
4881                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4882                    throws com.liferay.portal.kernel.exception.SystemException,
4883                            com.liferay.portlet.journal.NoSuchArticleException {
4884                    return getPersistence()
4885                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
4886                            status, orderByComparator);
4887            }
4888    
4889            /**
4890            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
4891            *
4892            * @param groupId the group ID
4893            * @param folderId the folder ID
4894            * @param statuses the statuses
4895            * @return the 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_F_ST(
4899                    long groupId, long folderId, int[] statuses)
4900                    throws com.liferay.portal.kernel.exception.SystemException {
4901                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
4902            }
4903    
4904            /**
4905            * 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;.
4906            *
4907            * <p>
4908            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4909            * </p>
4910            *
4911            * @param groupId the group ID
4912            * @param folderId the folder ID
4913            * @param statuses the statuses
4914            * @param start the lower bound of the range of journal articles
4915            * @param end the upper bound of the range of journal articles (not inclusive)
4916            * @return the range of matching journal articles that the user has permission to view
4917            * @throws SystemException if a system exception occurred
4918            */
4919            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4920                    long groupId, long folderId, int[] statuses, int start, int end)
4921                    throws com.liferay.portal.kernel.exception.SystemException {
4922                    return getPersistence()
4923                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
4924            }
4925    
4926            /**
4927            * 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;.
4928            *
4929            * <p>
4930            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4931            * </p>
4932            *
4933            * @param groupId the group ID
4934            * @param folderId the folder ID
4935            * @param statuses the statuses
4936            * @param start the lower bound of the range of journal articles
4937            * @param end the upper bound of the range of journal articles (not inclusive)
4938            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4939            * @return the ordered range of matching journal articles that the user has permission to view
4940            * @throws SystemException if a system exception occurred
4941            */
4942            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
4943                    long groupId, long folderId, int[] statuses, int start, int end,
4944                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4945                    throws com.liferay.portal.kernel.exception.SystemException {
4946                    return getPersistence()
4947                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
4948                            orderByComparator);
4949            }
4950    
4951            /**
4952            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4953            *
4954            * <p>
4955            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4956            * </p>
4957            *
4958            * @param groupId the group ID
4959            * @param folderId the folder ID
4960            * @param statuses the statuses
4961            * @return the matching journal articles
4962            * @throws SystemException if a system exception occurred
4963            */
4964            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4965                    long groupId, long folderId, int[] statuses)
4966                    throws com.liferay.portal.kernel.exception.SystemException {
4967                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
4968            }
4969    
4970            /**
4971            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4972            *
4973            * <p>
4974            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4975            * </p>
4976            *
4977            * @param groupId the group ID
4978            * @param folderId the folder ID
4979            * @param statuses the statuses
4980            * @param start the lower bound of the range of journal articles
4981            * @param end the upper bound of the range of journal articles (not inclusive)
4982            * @return the range of matching journal articles
4983            * @throws SystemException if a system exception occurred
4984            */
4985            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
4986                    long groupId, long folderId, int[] statuses, int start, int end)
4987                    throws com.liferay.portal.kernel.exception.SystemException {
4988                    return getPersistence()
4989                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
4990            }
4991    
4992            /**
4993            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4994            *
4995            * <p>
4996            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4997            * </p>
4998            *
4999            * @param groupId the group ID
5000            * @param folderId the folder ID
5001            * @param statuses the statuses
5002            * @param start the lower bound of the range of journal articles
5003            * @param end the upper bound of the range of journal articles (not inclusive)
5004            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5005            * @return the ordered range of matching journal articles
5006            * @throws SystemException if a system exception occurred
5007            */
5008            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5009                    long groupId, long folderId, int[] statuses, int start, int end,
5010                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5011                    throws com.liferay.portal.kernel.exception.SystemException {
5012                    return getPersistence()
5013                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
5014                            orderByComparator);
5015            }
5016    
5017            /**
5018            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
5019            *
5020            * @param groupId the group ID
5021            * @param folderId the folder ID
5022            * @param status the status
5023            * @throws SystemException if a system exception occurred
5024            */
5025            public static void removeByG_F_ST(long groupId, long folderId, int status)
5026                    throws com.liferay.portal.kernel.exception.SystemException {
5027                    getPersistence().removeByG_F_ST(groupId, folderId, status);
5028            }
5029    
5030            /**
5031            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5032            *
5033            * @param groupId the group ID
5034            * @param folderId the folder ID
5035            * @param status the status
5036            * @return the number of matching journal articles
5037            * @throws SystemException if a system exception occurred
5038            */
5039            public static int countByG_F_ST(long groupId, long folderId, int status)
5040                    throws com.liferay.portal.kernel.exception.SystemException {
5041                    return getPersistence().countByG_F_ST(groupId, folderId, status);
5042            }
5043    
5044            /**
5045            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5046            *
5047            * @param groupId the group ID
5048            * @param folderId the folder ID
5049            * @param statuses the statuses
5050            * @return the number of matching journal articles
5051            * @throws SystemException if a system exception occurred
5052            */
5053            public static int countByG_F_ST(long groupId, long folderId, int[] statuses)
5054                    throws com.liferay.portal.kernel.exception.SystemException {
5055                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
5056            }
5057    
5058            /**
5059            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5060            *
5061            * @param groupId the group ID
5062            * @param folderId the folder ID
5063            * @param status the status
5064            * @return the number of matching journal articles that the user has permission to view
5065            * @throws SystemException if a system exception occurred
5066            */
5067            public static int filterCountByG_F_ST(long groupId, long folderId,
5068                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5069                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
5070            }
5071    
5072            /**
5073            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5074            *
5075            * @param groupId the group ID
5076            * @param folderId the folder ID
5077            * @param statuses the statuses
5078            * @return the number of matching journal articles that the user has permission to view
5079            * @throws SystemException if a system exception occurred
5080            */
5081            public static int filterCountByG_F_ST(long groupId, long folderId,
5082                    int[] statuses)
5083                    throws com.liferay.portal.kernel.exception.SystemException {
5084                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
5085            }
5086    
5087            /**
5088            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5089            *
5090            * @param groupId the group ID
5091            * @param classNameId the class name ID
5092            * @param classPK the class p k
5093            * @return the matching journal articles
5094            * @throws SystemException if a system exception occurred
5095            */
5096            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5097                    long groupId, long classNameId, long classPK)
5098                    throws com.liferay.portal.kernel.exception.SystemException {
5099                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5100            }
5101    
5102            /**
5103            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5104            *
5105            * <p>
5106            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5107            * </p>
5108            *
5109            * @param groupId the group ID
5110            * @param classNameId the class name ID
5111            * @param classPK the class p k
5112            * @param start the lower bound of the range of journal articles
5113            * @param end the upper bound of the range of journal articles (not inclusive)
5114            * @return the range of matching journal articles
5115            * @throws SystemException if a system exception occurred
5116            */
5117            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5118                    long groupId, long classNameId, long classPK, int start, int end)
5119                    throws com.liferay.portal.kernel.exception.SystemException {
5120                    return getPersistence()
5121                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5122            }
5123    
5124            /**
5125            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5126            *
5127            * <p>
5128            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5129            * </p>
5130            *
5131            * @param groupId the group ID
5132            * @param classNameId the class name ID
5133            * @param classPK the class p k
5134            * @param start the lower bound of the range of journal articles
5135            * @param end the upper bound of the range of journal articles (not inclusive)
5136            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5137            * @return the ordered range of matching journal articles
5138            * @throws SystemException if a system exception occurred
5139            */
5140            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5141                    long groupId, long classNameId, long classPK, int start, int end,
5142                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5143                    throws com.liferay.portal.kernel.exception.SystemException {
5144                    return getPersistence()
5145                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
5146                            orderByComparator);
5147            }
5148    
5149            /**
5150            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5151            *
5152            * @param groupId the group ID
5153            * @param classNameId the class name ID
5154            * @param classPK the class p k
5155            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5156            * @return the first matching journal article
5157            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5158            * @throws SystemException if a system exception occurred
5159            */
5160            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
5161                    long groupId, long classNameId, long classPK,
5162                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5163                    throws com.liferay.portal.kernel.exception.SystemException,
5164                            com.liferay.portlet.journal.NoSuchArticleException {
5165                    return getPersistence()
5166                                       .findByG_C_C_First(groupId, classNameId, classPK,
5167                            orderByComparator);
5168            }
5169    
5170            /**
5171            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5172            *
5173            * @param groupId the group ID
5174            * @param classNameId the class name ID
5175            * @param classPK the class p k
5176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5177            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5178            * @throws SystemException if a system exception occurred
5179            */
5180            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
5181                    long groupId, long classNameId, long classPK,
5182                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5183                    throws com.liferay.portal.kernel.exception.SystemException {
5184                    return getPersistence()
5185                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5186                            orderByComparator);
5187            }
5188    
5189            /**
5190            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5191            *
5192            * @param groupId the group ID
5193            * @param classNameId the class name ID
5194            * @param classPK the class p k
5195            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5196            * @return the last matching journal article
5197            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5198            * @throws SystemException if a system exception occurred
5199            */
5200            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
5201                    long groupId, long classNameId, long classPK,
5202                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5203                    throws com.liferay.portal.kernel.exception.SystemException,
5204                            com.liferay.portlet.journal.NoSuchArticleException {
5205                    return getPersistence()
5206                                       .findByG_C_C_Last(groupId, classNameId, classPK,
5207                            orderByComparator);
5208            }
5209    
5210            /**
5211            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5212            *
5213            * @param groupId the group ID
5214            * @param classNameId the class name ID
5215            * @param classPK the class p k
5216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5217            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5218            * @throws SystemException if a system exception occurred
5219            */
5220            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
5221                    long groupId, long classNameId, long classPK,
5222                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5223                    throws com.liferay.portal.kernel.exception.SystemException {
5224                    return getPersistence()
5225                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
5226                            orderByComparator);
5227            }
5228    
5229            /**
5230            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5231            *
5232            * @param id the primary key of the current journal article
5233            * @param groupId the group ID
5234            * @param classNameId the class name ID
5235            * @param classPK the class p k
5236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5237            * @return the previous, current, and next journal article
5238            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5239            * @throws SystemException if a system exception occurred
5240            */
5241            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
5242                    long id, long groupId, long classNameId, long classPK,
5243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5244                    throws com.liferay.portal.kernel.exception.SystemException,
5245                            com.liferay.portlet.journal.NoSuchArticleException {
5246                    return getPersistence()
5247                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5248                            orderByComparator);
5249            }
5250    
5251            /**
5252            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5253            *
5254            * @param groupId the group ID
5255            * @param classNameId the class name ID
5256            * @param classPK the class p k
5257            * @return the matching journal articles that the user has permission to view
5258            * @throws SystemException if a system exception occurred
5259            */
5260            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5261                    long groupId, long classNameId, long classPK)
5262                    throws com.liferay.portal.kernel.exception.SystemException {
5263                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5264            }
5265    
5266            /**
5267            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5268            *
5269            * <p>
5270            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5271            * </p>
5272            *
5273            * @param groupId the group ID
5274            * @param classNameId the class name ID
5275            * @param classPK the class p k
5276            * @param start the lower bound of the range of journal articles
5277            * @param end the upper bound of the range of journal articles (not inclusive)
5278            * @return the range of matching journal articles that the user has permission to view
5279            * @throws SystemException if a system exception occurred
5280            */
5281            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5282                    long groupId, long classNameId, long classPK, int start, int end)
5283                    throws com.liferay.portal.kernel.exception.SystemException {
5284                    return getPersistence()
5285                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
5286            }
5287    
5288            /**
5289            * 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;.
5290            *
5291            * <p>
5292            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5293            * </p>
5294            *
5295            * @param groupId the group ID
5296            * @param classNameId the class name ID
5297            * @param classPK the class p k
5298            * @param start the lower bound of the range of journal articles
5299            * @param end the upper bound of the range of journal articles (not inclusive)
5300            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5301            * @return the ordered range of matching journal articles that the user has permission to view
5302            * @throws SystemException if a system exception occurred
5303            */
5304            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5305                    long groupId, long classNameId, long classPK, int start, int end,
5306                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5307                    throws com.liferay.portal.kernel.exception.SystemException {
5308                    return getPersistence()
5309                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
5310                            end, orderByComparator);
5311            }
5312    
5313            /**
5314            * 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;.
5315            *
5316            * @param id the primary key of the current journal article
5317            * @param groupId the group ID
5318            * @param classNameId the class name ID
5319            * @param classPK the class p k
5320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5321            * @return the previous, current, and next journal article
5322            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5323            * @throws SystemException if a system exception occurred
5324            */
5325            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
5326                    long id, long groupId, long classNameId, long classPK,
5327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5328                    throws com.liferay.portal.kernel.exception.SystemException,
5329                            com.liferay.portlet.journal.NoSuchArticleException {
5330                    return getPersistence()
5331                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
5332                            classPK, orderByComparator);
5333            }
5334    
5335            /**
5336            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5337            *
5338            * @param groupId the group ID
5339            * @param classNameId the class name ID
5340            * @param classPK the class p k
5341            * @throws SystemException if a system exception occurred
5342            */
5343            public static void removeByG_C_C(long groupId, long classNameId,
5344                    long classPK)
5345                    throws com.liferay.portal.kernel.exception.SystemException {
5346                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5347            }
5348    
5349            /**
5350            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5351            *
5352            * @param groupId the group ID
5353            * @param classNameId the class name ID
5354            * @param classPK the class p k
5355            * @return the number of matching journal articles
5356            * @throws SystemException if a system exception occurred
5357            */
5358            public static int countByG_C_C(long groupId, long classNameId, long classPK)
5359                    throws com.liferay.portal.kernel.exception.SystemException {
5360                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5361            }
5362    
5363            /**
5364            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5365            *
5366            * @param groupId the group ID
5367            * @param classNameId the class name ID
5368            * @param classPK the class p k
5369            * @return the number of matching journal articles that the user has permission to view
5370            * @throws SystemException if a system exception occurred
5371            */
5372            public static int filterCountByG_C_C(long groupId, long classNameId,
5373                    long classPK)
5374                    throws com.liferay.portal.kernel.exception.SystemException {
5375                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5376            }
5377    
5378            /**
5379            * 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.
5380            *
5381            * @param groupId the group ID
5382            * @param classNameId the class name ID
5383            * @param structureId the structure ID
5384            * @return the matching journal article
5385            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5386            * @throws SystemException if a system exception occurred
5387            */
5388            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
5389                    long groupId, long classNameId, java.lang.String structureId)
5390                    throws com.liferay.portal.kernel.exception.SystemException,
5391                            com.liferay.portlet.journal.NoSuchArticleException {
5392                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
5393            }
5394    
5395            /**
5396            * 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.
5397            *
5398            * @param groupId the group ID
5399            * @param classNameId the class name ID
5400            * @param structureId the structure ID
5401            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5402            * @throws SystemException if a system exception occurred
5403            */
5404            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
5405                    long groupId, long classNameId, java.lang.String structureId)
5406                    throws com.liferay.portal.kernel.exception.SystemException {
5407                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
5408            }
5409    
5410            /**
5411            * 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.
5412            *
5413            * @param groupId the group ID
5414            * @param classNameId the class name ID
5415            * @param structureId the structure ID
5416            * @param retrieveFromCache whether to use the finder cache
5417            * @return the matching journal article, or <code>null</code> 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 fetchByG_C_S(
5421                    long groupId, long classNameId, java.lang.String structureId,
5422                    boolean retrieveFromCache)
5423                    throws com.liferay.portal.kernel.exception.SystemException {
5424                    return getPersistence()
5425                                       .fetchByG_C_S(groupId, classNameId, structureId,
5426                            retrieveFromCache);
5427            }
5428    
5429            /**
5430            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
5431            *
5432            * @param groupId the group ID
5433            * @param classNameId the class name ID
5434            * @param structureId the structure ID
5435            * @return the journal article that was removed
5436            * @throws SystemException if a system exception occurred
5437            */
5438            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
5439                    long groupId, long classNameId, java.lang.String structureId)
5440                    throws com.liferay.portal.kernel.exception.SystemException,
5441                            com.liferay.portlet.journal.NoSuchArticleException {
5442                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
5443            }
5444    
5445            /**
5446            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
5447            *
5448            * @param groupId the group ID
5449            * @param classNameId the class name ID
5450            * @param structureId the structure ID
5451            * @return the number of matching journal articles
5452            * @throws SystemException if a system exception occurred
5453            */
5454            public static int countByG_C_S(long groupId, long classNameId,
5455                    java.lang.String structureId)
5456                    throws com.liferay.portal.kernel.exception.SystemException {
5457                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
5458            }
5459    
5460            /**
5461            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5462            *
5463            * @param groupId the group ID
5464            * @param classNameId the class name ID
5465            * @param templateId the template ID
5466            * @return the matching journal articles
5467            * @throws SystemException if a system exception occurred
5468            */
5469            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5470                    long groupId, long classNameId, java.lang.String templateId)
5471                    throws com.liferay.portal.kernel.exception.SystemException {
5472                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
5473            }
5474    
5475            /**
5476            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5477            *
5478            * <p>
5479            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5480            * </p>
5481            *
5482            * @param groupId the group ID
5483            * @param classNameId the class name ID
5484            * @param templateId the template ID
5485            * @param start the lower bound of the range of journal articles
5486            * @param end the upper bound of the range of journal articles (not inclusive)
5487            * @return the range of matching journal articles
5488            * @throws SystemException if a system exception occurred
5489            */
5490            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5491                    long groupId, long classNameId, java.lang.String templateId, int start,
5492                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5493                    return getPersistence()
5494                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
5495            }
5496    
5497            /**
5498            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5499            *
5500            * <p>
5501            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5502            * </p>
5503            *
5504            * @param groupId the group ID
5505            * @param classNameId the class name ID
5506            * @param templateId the template ID
5507            * @param start the lower bound of the range of journal articles
5508            * @param end the upper bound of the range of journal articles (not inclusive)
5509            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5510            * @return the ordered range of matching journal articles
5511            * @throws SystemException if a system exception occurred
5512            */
5513            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
5514                    long groupId, long classNameId, java.lang.String templateId, int start,
5515                    int end,
5516                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5517                    throws com.liferay.portal.kernel.exception.SystemException {
5518                    return getPersistence()
5519                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
5520                            orderByComparator);
5521            }
5522    
5523            /**
5524            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5525            *
5526            * @param groupId the group ID
5527            * @param classNameId the class name ID
5528            * @param templateId the template ID
5529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5530            * @return the first matching journal article
5531            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5532            * @throws SystemException if a system exception occurred
5533            */
5534            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
5535                    long groupId, long classNameId, java.lang.String templateId,
5536                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5537                    throws com.liferay.portal.kernel.exception.SystemException,
5538                            com.liferay.portlet.journal.NoSuchArticleException {
5539                    return getPersistence()
5540                                       .findByG_C_T_First(groupId, classNameId, templateId,
5541                            orderByComparator);
5542            }
5543    
5544            /**
5545            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5546            *
5547            * @param groupId the group ID
5548            * @param classNameId the class name ID
5549            * @param templateId the template ID
5550            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5551            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5552            * @throws SystemException if a system exception occurred
5553            */
5554            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
5555                    long groupId, long classNameId, java.lang.String templateId,
5556                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5557                    throws com.liferay.portal.kernel.exception.SystemException {
5558                    return getPersistence()
5559                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
5560                            orderByComparator);
5561            }
5562    
5563            /**
5564            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5565            *
5566            * @param groupId the group ID
5567            * @param classNameId the class name ID
5568            * @param templateId the template ID
5569            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5570            * @return the last matching journal article
5571            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5572            * @throws SystemException if a system exception occurred
5573            */
5574            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
5575                    long groupId, long classNameId, java.lang.String templateId,
5576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5577                    throws com.liferay.portal.kernel.exception.SystemException,
5578                            com.liferay.portlet.journal.NoSuchArticleException {
5579                    return getPersistence()
5580                                       .findByG_C_T_Last(groupId, classNameId, templateId,
5581                            orderByComparator);
5582            }
5583    
5584            /**
5585            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5586            *
5587            * @param groupId the group ID
5588            * @param classNameId the class name ID
5589            * @param templateId the template ID
5590            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5591            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5592            * @throws SystemException if a system exception occurred
5593            */
5594            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
5595                    long groupId, long classNameId, java.lang.String templateId,
5596                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5597                    throws com.liferay.portal.kernel.exception.SystemException {
5598                    return getPersistence()
5599                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
5600                            orderByComparator);
5601            }
5602    
5603            /**
5604            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5605            *
5606            * @param id the primary key of the current journal article
5607            * @param groupId the group ID
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 previous, current, and next journal article
5612            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5613            * @throws SystemException if a system exception occurred
5614            */
5615            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
5616                    long id, long groupId, long classNameId, java.lang.String templateId,
5617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5618                    throws com.liferay.portal.kernel.exception.SystemException,
5619                            com.liferay.portlet.journal.NoSuchArticleException {
5620                    return getPersistence()
5621                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
5622                            templateId, orderByComparator);
5623            }
5624    
5625            /**
5626            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5627            *
5628            * @param groupId the group ID
5629            * @param classNameId the class name ID
5630            * @param templateId the template ID
5631            * @return the matching journal articles that the user has permission to view
5632            * @throws SystemException if a system exception occurred
5633            */
5634            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5635                    long groupId, long classNameId, java.lang.String templateId)
5636                    throws com.liferay.portal.kernel.exception.SystemException {
5637                    return getPersistence()
5638                                       .filterFindByG_C_T(groupId, classNameId, templateId);
5639            }
5640    
5641            /**
5642            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5643            *
5644            * <p>
5645            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5646            * </p>
5647            *
5648            * @param groupId the group ID
5649            * @param classNameId the class name ID
5650            * @param templateId the template ID
5651            * @param start the lower bound of the range of journal articles
5652            * @param end the upper bound of the range of journal articles (not inclusive)
5653            * @return the range of matching journal articles that the user has permission to view
5654            * @throws SystemException if a system exception occurred
5655            */
5656            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5657                    long groupId, long classNameId, java.lang.String templateId, int start,
5658                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5659                    return getPersistence()
5660                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
5661                            end);
5662            }
5663    
5664            /**
5665            * 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;.
5666            *
5667            * <p>
5668            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5669            * </p>
5670            *
5671            * @param groupId the group ID
5672            * @param classNameId the class name ID
5673            * @param templateId the template ID
5674            * @param start the lower bound of the range of journal articles
5675            * @param end the upper bound of the range of journal articles (not inclusive)
5676            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5677            * @return the ordered range of matching journal articles that the user has permission to view
5678            * @throws SystemException if a system exception occurred
5679            */
5680            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
5681                    long groupId, long classNameId, java.lang.String templateId, int start,
5682                    int end,
5683                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5684                    throws com.liferay.portal.kernel.exception.SystemException {
5685                    return getPersistence()
5686                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
5687                            end, orderByComparator);
5688            }
5689    
5690            /**
5691            * 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;.
5692            *
5693            * @param id the primary key of the current journal article
5694            * @param groupId the group ID
5695            * @param classNameId the class name ID
5696            * @param templateId the template ID
5697            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5698            * @return the previous, current, and next journal article
5699            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5700            * @throws SystemException if a system exception occurred
5701            */
5702            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
5703                    long id, long groupId, long classNameId, java.lang.String templateId,
5704                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5705                    throws com.liferay.portal.kernel.exception.SystemException,
5706                            com.liferay.portlet.journal.NoSuchArticleException {
5707                    return getPersistence()
5708                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
5709                            templateId, orderByComparator);
5710            }
5711    
5712            /**
5713            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
5714            *
5715            * @param groupId the group ID
5716            * @param classNameId the class name ID
5717            * @param templateId the template ID
5718            * @throws SystemException if a system exception occurred
5719            */
5720            public static void removeByG_C_T(long groupId, long classNameId,
5721                    java.lang.String templateId)
5722                    throws com.liferay.portal.kernel.exception.SystemException {
5723                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
5724            }
5725    
5726            /**
5727            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5728            *
5729            * @param groupId the group ID
5730            * @param classNameId the class name ID
5731            * @param templateId the template ID
5732            * @return the number of matching journal articles
5733            * @throws SystemException if a system exception occurred
5734            */
5735            public static int countByG_C_T(long groupId, long classNameId,
5736                    java.lang.String templateId)
5737                    throws com.liferay.portal.kernel.exception.SystemException {
5738                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
5739            }
5740    
5741            /**
5742            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5743            *
5744            * @param groupId the group ID
5745            * @param classNameId the class name ID
5746            * @param templateId the template ID
5747            * @return the number of matching journal articles that the user has permission to view
5748            * @throws SystemException if a system exception occurred
5749            */
5750            public static int filterCountByG_C_T(long groupId, long classNameId,
5751                    java.lang.String templateId)
5752                    throws com.liferay.portal.kernel.exception.SystemException {
5753                    return getPersistence()
5754                                       .filterCountByG_C_T(groupId, classNameId, templateId);
5755            }
5756    
5757            /**
5758            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5759            *
5760            * @param groupId the group ID
5761            * @param classNameId the class name ID
5762            * @param layoutUuid the layout uuid
5763            * @return the matching journal articles
5764            * @throws SystemException if a system exception occurred
5765            */
5766            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5767                    long groupId, long classNameId, java.lang.String layoutUuid)
5768                    throws com.liferay.portal.kernel.exception.SystemException {
5769                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
5770            }
5771    
5772            /**
5773            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5774            *
5775            * <p>
5776            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5777            * </p>
5778            *
5779            * @param groupId the group ID
5780            * @param classNameId the class name ID
5781            * @param layoutUuid the layout uuid
5782            * @param start the lower bound of the range of journal articles
5783            * @param end the upper bound of the range of journal articles (not inclusive)
5784            * @return the range of matching journal articles
5785            * @throws SystemException if a system exception occurred
5786            */
5787            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5788                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5789                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5790                    return getPersistence()
5791                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
5792            }
5793    
5794            /**
5795            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5796            *
5797            * <p>
5798            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5799            * </p>
5800            *
5801            * @param groupId the group ID
5802            * @param classNameId the class name ID
5803            * @param layoutUuid the layout uuid
5804            * @param start the lower bound of the range of journal articles
5805            * @param end the upper bound of the range of journal articles (not inclusive)
5806            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5807            * @return the ordered range of matching journal articles
5808            * @throws SystemException if a system exception occurred
5809            */
5810            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
5811                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5812                    int end,
5813                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5814                    throws com.liferay.portal.kernel.exception.SystemException {
5815                    return getPersistence()
5816                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
5817                            orderByComparator);
5818            }
5819    
5820            /**
5821            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5822            *
5823            * @param groupId the group ID
5824            * @param classNameId the class name ID
5825            * @param layoutUuid the layout uuid
5826            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5827            * @return the first matching journal article
5828            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5829            * @throws SystemException if a system exception occurred
5830            */
5831            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
5832                    long groupId, long classNameId, java.lang.String layoutUuid,
5833                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5834                    throws com.liferay.portal.kernel.exception.SystemException,
5835                            com.liferay.portlet.journal.NoSuchArticleException {
5836                    return getPersistence()
5837                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
5838                            orderByComparator);
5839            }
5840    
5841            /**
5842            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5843            *
5844            * @param groupId the group ID
5845            * @param classNameId the class name ID
5846            * @param layoutUuid the layout uuid
5847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5848            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5849            * @throws SystemException if a system exception occurred
5850            */
5851            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
5852                    long groupId, long classNameId, java.lang.String layoutUuid,
5853                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5854                    throws com.liferay.portal.kernel.exception.SystemException {
5855                    return getPersistence()
5856                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
5857                            orderByComparator);
5858            }
5859    
5860            /**
5861            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5862            *
5863            * @param groupId the group ID
5864            * @param classNameId the class name ID
5865            * @param layoutUuid the layout uuid
5866            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5867            * @return the last matching journal article
5868            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5869            * @throws SystemException if a system exception occurred
5870            */
5871            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
5872                    long groupId, long classNameId, java.lang.String layoutUuid,
5873                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5874                    throws com.liferay.portal.kernel.exception.SystemException,
5875                            com.liferay.portlet.journal.NoSuchArticleException {
5876                    return getPersistence()
5877                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
5878                            orderByComparator);
5879            }
5880    
5881            /**
5882            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5883            *
5884            * @param groupId the group ID
5885            * @param classNameId the class name ID
5886            * @param layoutUuid the layout uuid
5887            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5888            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5889            * @throws SystemException if a system exception occurred
5890            */
5891            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
5892                    long groupId, long classNameId, java.lang.String layoutUuid,
5893                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5894                    throws com.liferay.portal.kernel.exception.SystemException {
5895                    return getPersistence()
5896                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
5897                            orderByComparator);
5898            }
5899    
5900            /**
5901            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5902            *
5903            * @param id the primary key of the current journal article
5904            * @param groupId the group ID
5905            * @param classNameId the class name ID
5906            * @param layoutUuid the layout uuid
5907            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5908            * @return the previous, current, and next journal article
5909            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5910            * @throws SystemException if a system exception occurred
5911            */
5912            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
5913                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
5914                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5915                    throws com.liferay.portal.kernel.exception.SystemException,
5916                            com.liferay.portlet.journal.NoSuchArticleException {
5917                    return getPersistence()
5918                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
5919                            layoutUuid, orderByComparator);
5920            }
5921    
5922            /**
5923            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5924            *
5925            * @param groupId the group ID
5926            * @param classNameId the class name ID
5927            * @param layoutUuid the layout uuid
5928            * @return the matching journal articles that the user has permission to view
5929            * @throws SystemException if a system exception occurred
5930            */
5931            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
5932                    long groupId, long classNameId, java.lang.String layoutUuid)
5933                    throws com.liferay.portal.kernel.exception.SystemException {
5934                    return getPersistence()
5935                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
5936            }
5937    
5938            /**
5939            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5940            *
5941            * <p>
5942            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5943            * </p>
5944            *
5945            * @param groupId the group ID
5946            * @param classNameId the class name ID
5947            * @param layoutUuid the layout uuid
5948            * @param start the lower bound of the range of journal articles
5949            * @param end the upper bound of the range of journal articles (not inclusive)
5950            * @return the range of matching journal articles that the user has permission to view
5951            * @throws SystemException if a system exception occurred
5952            */
5953            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
5954                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5955                    int end) throws com.liferay.portal.kernel.exception.SystemException {
5956                    return getPersistence()
5957                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
5958                            end);
5959            }
5960    
5961            /**
5962            * 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;.
5963            *
5964            * <p>
5965            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5966            * </p>
5967            *
5968            * @param groupId the group ID
5969            * @param classNameId the class name ID
5970            * @param layoutUuid the layout uuid
5971            * @param start the lower bound of the range of journal articles
5972            * @param end the upper bound of the range of journal articles (not inclusive)
5973            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5974            * @return the ordered range of matching journal articles that the user has permission to view
5975            * @throws SystemException if a system exception occurred
5976            */
5977            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
5978                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
5979                    int end,
5980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5981                    throws com.liferay.portal.kernel.exception.SystemException {
5982                    return getPersistence()
5983                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
5984                            end, orderByComparator);
5985            }
5986    
5987            /**
5988            * 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;.
5989            *
5990            * @param id the primary key of the current journal article
5991            * @param groupId the group ID
5992            * @param classNameId the class name ID
5993            * @param layoutUuid the layout uuid
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[] filterFindByG_C_L_PrevAndNext(
6000                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
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                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6006                            layoutUuid, orderByComparator);
6007            }
6008    
6009            /**
6010            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6011            *
6012            * @param groupId the group ID
6013            * @param classNameId the class name ID
6014            * @param layoutUuid the layout uuid
6015            * @throws SystemException if a system exception occurred
6016            */
6017            public static void removeByG_C_L(long groupId, long classNameId,
6018                    java.lang.String layoutUuid)
6019                    throws com.liferay.portal.kernel.exception.SystemException {
6020                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6021            }
6022    
6023            /**
6024            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6025            *
6026            * @param groupId the group ID
6027            * @param classNameId the class name ID
6028            * @param layoutUuid the layout uuid
6029            * @return the number of matching journal articles
6030            * @throws SystemException if a system exception occurred
6031            */
6032            public static int countByG_C_L(long groupId, long classNameId,
6033                    java.lang.String layoutUuid)
6034                    throws com.liferay.portal.kernel.exception.SystemException {
6035                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6036            }
6037    
6038            /**
6039            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6040            *
6041            * @param groupId the group ID
6042            * @param classNameId the class name ID
6043            * @param layoutUuid the layout uuid
6044            * @return the number of matching journal articles that the user has permission to view
6045            * @throws SystemException if a system exception occurred
6046            */
6047            public static int filterCountByG_C_L(long groupId, long classNameId,
6048                    java.lang.String layoutUuid)
6049                    throws com.liferay.portal.kernel.exception.SystemException {
6050                    return getPersistence()
6051                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
6052            }
6053    
6054            /**
6055            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6056            *
6057            * @param groupId the group ID
6058            * @param userId the user ID
6059            * @param classNameId the class name ID
6060            * @return the matching journal articles
6061            * @throws SystemException if a system exception occurred
6062            */
6063            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6064                    long groupId, long userId, long classNameId)
6065                    throws com.liferay.portal.kernel.exception.SystemException {
6066                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
6067            }
6068    
6069            /**
6070            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6071            *
6072            * <p>
6073            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6074            * </p>
6075            *
6076            * @param groupId the group ID
6077            * @param userId the user ID
6078            * @param classNameId the class name ID
6079            * @param start the lower bound of the range of journal articles
6080            * @param end the upper bound of the range of journal articles (not inclusive)
6081            * @return the range of matching journal articles
6082            * @throws SystemException if a system exception occurred
6083            */
6084            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6085                    long groupId, long userId, long classNameId, int start, int end)
6086                    throws com.liferay.portal.kernel.exception.SystemException {
6087                    return getPersistence()
6088                                       .findByG_U_C(groupId, userId, classNameId, start, end);
6089            }
6090    
6091            /**
6092            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6093            *
6094            * <p>
6095            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6096            * </p>
6097            *
6098            * @param groupId the group ID
6099            * @param userId the user ID
6100            * @param classNameId the class name ID
6101            * @param start the lower bound of the range of journal articles
6102            * @param end the upper bound of the range of journal articles (not inclusive)
6103            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6104            * @return the ordered range of matching journal articles
6105            * @throws SystemException if a system exception occurred
6106            */
6107            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
6108                    long groupId, long userId, long classNameId, int start, int end,
6109                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6110                    throws com.liferay.portal.kernel.exception.SystemException {
6111                    return getPersistence()
6112                                       .findByG_U_C(groupId, userId, classNameId, start, end,
6113                            orderByComparator);
6114            }
6115    
6116            /**
6117            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6118            *
6119            * @param groupId the group ID
6120            * @param userId the user ID
6121            * @param classNameId the class name ID
6122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6123            * @return the first matching journal article
6124            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6125            * @throws SystemException if a system exception occurred
6126            */
6127            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
6128                    long groupId, long userId, long classNameId,
6129                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6130                    throws com.liferay.portal.kernel.exception.SystemException,
6131                            com.liferay.portlet.journal.NoSuchArticleException {
6132                    return getPersistence()
6133                                       .findByG_U_C_First(groupId, userId, classNameId,
6134                            orderByComparator);
6135            }
6136    
6137            /**
6138            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6139            *
6140            * @param groupId the group ID
6141            * @param userId the user ID
6142            * @param classNameId the class name ID
6143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6144            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6145            * @throws SystemException if a system exception occurred
6146            */
6147            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
6148                    long groupId, long userId, long classNameId,
6149                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6150                    throws com.liferay.portal.kernel.exception.SystemException {
6151                    return getPersistence()
6152                                       .fetchByG_U_C_First(groupId, userId, classNameId,
6153                            orderByComparator);
6154            }
6155    
6156            /**
6157            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6158            *
6159            * @param groupId the group ID
6160            * @param userId the user ID
6161            * @param classNameId the class name ID
6162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6163            * @return the last matching journal article
6164            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6165            * @throws SystemException if a system exception occurred
6166            */
6167            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
6168                    long groupId, long userId, long classNameId,
6169                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6170                    throws com.liferay.portal.kernel.exception.SystemException,
6171                            com.liferay.portlet.journal.NoSuchArticleException {
6172                    return getPersistence()
6173                                       .findByG_U_C_Last(groupId, userId, classNameId,
6174                            orderByComparator);
6175            }
6176    
6177            /**
6178            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6179            *
6180            * @param groupId the group ID
6181            * @param userId the user ID
6182            * @param classNameId the class name ID
6183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6184            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6185            * @throws SystemException if a system exception occurred
6186            */
6187            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
6188                    long groupId, long userId, long classNameId,
6189                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6190                    throws com.liferay.portal.kernel.exception.SystemException {
6191                    return getPersistence()
6192                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
6193                            orderByComparator);
6194            }
6195    
6196            /**
6197            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6198            *
6199            * @param id the primary key of the current journal article
6200            * @param groupId the group ID
6201            * @param userId the user ID
6202            * @param classNameId the class name ID
6203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6204            * @return the previous, current, and next journal article
6205            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6206            * @throws SystemException if a system exception occurred
6207            */
6208            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
6209                    long id, long groupId, long userId, long classNameId,
6210                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6211                    throws com.liferay.portal.kernel.exception.SystemException,
6212                            com.liferay.portlet.journal.NoSuchArticleException {
6213                    return getPersistence()
6214                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
6215                            orderByComparator);
6216            }
6217    
6218            /**
6219            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6220            *
6221            * @param groupId the group ID
6222            * @param userId the user ID
6223            * @param classNameId the class name ID
6224            * @return the matching journal articles that the user has permission to view
6225            * @throws SystemException if a system exception occurred
6226            */
6227            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6228                    long groupId, long userId, long classNameId)
6229                    throws com.liferay.portal.kernel.exception.SystemException {
6230                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
6231            }
6232    
6233            /**
6234            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6235            *
6236            * <p>
6237            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6238            * </p>
6239            *
6240            * @param groupId the group ID
6241            * @param userId the user ID
6242            * @param classNameId the class name ID
6243            * @param start the lower bound of the range of journal articles
6244            * @param end the upper bound of the range of journal articles (not inclusive)
6245            * @return the range of matching journal articles that the user has permission to view
6246            * @throws SystemException if a system exception occurred
6247            */
6248            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6249                    long groupId, long userId, long classNameId, int start, int end)
6250                    throws com.liferay.portal.kernel.exception.SystemException {
6251                    return getPersistence()
6252                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
6253            }
6254    
6255            /**
6256            * 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;.
6257            *
6258            * <p>
6259            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6260            * </p>
6261            *
6262            * @param groupId the group ID
6263            * @param userId the user ID
6264            * @param classNameId the class name ID
6265            * @param start the lower bound of the range of journal articles
6266            * @param end the upper bound of the range of journal articles (not inclusive)
6267            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6268            * @return the ordered range of matching journal articles that the user has permission to view
6269            * @throws SystemException if a system exception occurred
6270            */
6271            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
6272                    long groupId, long userId, long classNameId, int start, int end,
6273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6274                    throws com.liferay.portal.kernel.exception.SystemException {
6275                    return getPersistence()
6276                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
6277                            orderByComparator);
6278            }
6279    
6280            /**
6281            * 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;.
6282            *
6283            * @param id the primary key of the current journal article
6284            * @param groupId the group ID
6285            * @param userId the user ID
6286            * @param classNameId the class name ID
6287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6288            * @return the previous, current, and next journal article
6289            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6290            * @throws SystemException if a system exception occurred
6291            */
6292            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
6293                    long id, long groupId, long userId, long classNameId,
6294                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6295                    throws com.liferay.portal.kernel.exception.SystemException,
6296                            com.liferay.portlet.journal.NoSuchArticleException {
6297                    return getPersistence()
6298                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
6299                            classNameId, orderByComparator);
6300            }
6301    
6302            /**
6303            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
6304            *
6305            * @param groupId the group ID
6306            * @param userId the user ID
6307            * @param classNameId the class name ID
6308            * @throws SystemException if a system exception occurred
6309            */
6310            public static void removeByG_U_C(long groupId, long userId, long classNameId)
6311                    throws com.liferay.portal.kernel.exception.SystemException {
6312                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
6313            }
6314    
6315            /**
6316            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6317            *
6318            * @param groupId the group ID
6319            * @param userId the user ID
6320            * @param classNameId the class name ID
6321            * @return the number of matching journal articles
6322            * @throws SystemException if a system exception occurred
6323            */
6324            public static int countByG_U_C(long groupId, long userId, long classNameId)
6325                    throws com.liferay.portal.kernel.exception.SystemException {
6326                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
6327            }
6328    
6329            /**
6330            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
6331            *
6332            * @param groupId the group ID
6333            * @param userId the user ID
6334            * @param classNameId the class name ID
6335            * @return the number of matching journal articles that the user has permission to view
6336            * @throws SystemException if a system exception occurred
6337            */
6338            public static int filterCountByG_U_C(long groupId, long userId,
6339                    long classNameId)
6340                    throws com.liferay.portal.kernel.exception.SystemException {
6341                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
6342            }
6343    
6344            /**
6345            * 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.
6346            *
6347            * @param groupId the group ID
6348            * @param articleId the article ID
6349            * @param version the version
6350            * @return the matching journal article
6351            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6352            * @throws SystemException if a system exception occurred
6353            */
6354            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
6355                    long groupId, java.lang.String articleId, double version)
6356                    throws com.liferay.portal.kernel.exception.SystemException,
6357                            com.liferay.portlet.journal.NoSuchArticleException {
6358                    return getPersistence().findByG_A_V(groupId, articleId, version);
6359            }
6360    
6361            /**
6362            * 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.
6363            *
6364            * @param groupId the group ID
6365            * @param articleId the article ID
6366            * @param version the version
6367            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6368            * @throws SystemException if a system exception occurred
6369            */
6370            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6371                    long groupId, java.lang.String articleId, double version)
6372                    throws com.liferay.portal.kernel.exception.SystemException {
6373                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
6374            }
6375    
6376            /**
6377            * 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.
6378            *
6379            * @param groupId the group ID
6380            * @param articleId the article ID
6381            * @param version the version
6382            * @param retrieveFromCache whether to use the finder cache
6383            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6384            * @throws SystemException if a system exception occurred
6385            */
6386            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6387                    long groupId, java.lang.String articleId, double version,
6388                    boolean retrieveFromCache)
6389                    throws com.liferay.portal.kernel.exception.SystemException {
6390                    return getPersistence()
6391                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
6392            }
6393    
6394            /**
6395            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
6396            *
6397            * @param groupId the group ID
6398            * @param articleId the article ID
6399            * @param version the version
6400            * @return the journal article that was removed
6401            * @throws SystemException if a system exception occurred
6402            */
6403            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
6404                    long groupId, java.lang.String articleId, double version)
6405                    throws com.liferay.portal.kernel.exception.SystemException,
6406                            com.liferay.portlet.journal.NoSuchArticleException {
6407                    return getPersistence().removeByG_A_V(groupId, articleId, version);
6408            }
6409    
6410            /**
6411            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
6412            *
6413            * @param groupId the group ID
6414            * @param articleId the article ID
6415            * @param version the version
6416            * @return the number of matching journal articles
6417            * @throws SystemException if a system exception occurred
6418            */
6419            public static int countByG_A_V(long groupId, java.lang.String articleId,
6420                    double version)
6421                    throws com.liferay.portal.kernel.exception.SystemException {
6422                    return getPersistence().countByG_A_V(groupId, articleId, version);
6423            }
6424    
6425            /**
6426            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6427            *
6428            * @param groupId the group ID
6429            * @param articleId the article ID
6430            * @param status the status
6431            * @return the matching journal articles
6432            * @throws SystemException if a system exception occurred
6433            */
6434            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6435                    long groupId, java.lang.String articleId, int status)
6436                    throws com.liferay.portal.kernel.exception.SystemException {
6437                    return getPersistence().findByG_A_ST(groupId, articleId, status);
6438            }
6439    
6440            /**
6441            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6442            *
6443            * <p>
6444            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6445            * </p>
6446            *
6447            * @param groupId the group ID
6448            * @param articleId the article ID
6449            * @param status the status
6450            * @param start the lower bound of the range of journal articles
6451            * @param end the upper bound of the range of journal articles (not inclusive)
6452            * @return the range of matching journal articles
6453            * @throws SystemException if a system exception occurred
6454            */
6455            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6456                    long groupId, java.lang.String articleId, int status, int start, int end)
6457                    throws com.liferay.portal.kernel.exception.SystemException {
6458                    return getPersistence()
6459                                       .findByG_A_ST(groupId, articleId, status, start, end);
6460            }
6461    
6462            /**
6463            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6464            *
6465            * <p>
6466            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6467            * </p>
6468            *
6469            * @param groupId the group ID
6470            * @param articleId the article ID
6471            * @param status the status
6472            * @param start the lower bound of the range of journal articles
6473            * @param end the upper bound of the range of journal articles (not inclusive)
6474            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6475            * @return the ordered range of matching journal articles
6476            * @throws SystemException if a system exception occurred
6477            */
6478            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6479                    long groupId, java.lang.String articleId, int status, int start,
6480                    int end,
6481                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6482                    throws com.liferay.portal.kernel.exception.SystemException {
6483                    return getPersistence()
6484                                       .findByG_A_ST(groupId, articleId, status, start, end,
6485                            orderByComparator);
6486            }
6487    
6488            /**
6489            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6490            *
6491            * @param groupId the group ID
6492            * @param articleId the article ID
6493            * @param status the status
6494            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6495            * @return the first matching journal article
6496            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6497            * @throws SystemException if a system exception occurred
6498            */
6499            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
6500                    long groupId, java.lang.String articleId, int status,
6501                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6502                    throws com.liferay.portal.kernel.exception.SystemException,
6503                            com.liferay.portlet.journal.NoSuchArticleException {
6504                    return getPersistence()
6505                                       .findByG_A_ST_First(groupId, articleId, status,
6506                            orderByComparator);
6507            }
6508    
6509            /**
6510            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6511            *
6512            * @param groupId the group ID
6513            * @param articleId the article ID
6514            * @param status the status
6515            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6516            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6517            * @throws SystemException if a system exception occurred
6518            */
6519            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
6520                    long groupId, java.lang.String articleId, int status,
6521                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6522                    throws com.liferay.portal.kernel.exception.SystemException {
6523                    return getPersistence()
6524                                       .fetchByG_A_ST_First(groupId, articleId, status,
6525                            orderByComparator);
6526            }
6527    
6528            /**
6529            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6530            *
6531            * @param groupId the group ID
6532            * @param articleId the article ID
6533            * @param status the status
6534            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6535            * @return the last matching journal article
6536            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6537            * @throws SystemException if a system exception occurred
6538            */
6539            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
6540                    long groupId, java.lang.String articleId, int status,
6541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6542                    throws com.liferay.portal.kernel.exception.SystemException,
6543                            com.liferay.portlet.journal.NoSuchArticleException {
6544                    return getPersistence()
6545                                       .findByG_A_ST_Last(groupId, articleId, status,
6546                            orderByComparator);
6547            }
6548    
6549            /**
6550            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6551            *
6552            * @param groupId the group ID
6553            * @param articleId the article ID
6554            * @param status the status
6555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6556            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6557            * @throws SystemException if a system exception occurred
6558            */
6559            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
6560                    long groupId, java.lang.String articleId, int status,
6561                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6562                    throws com.liferay.portal.kernel.exception.SystemException {
6563                    return getPersistence()
6564                                       .fetchByG_A_ST_Last(groupId, articleId, status,
6565                            orderByComparator);
6566            }
6567    
6568            /**
6569            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6570            *
6571            * @param id the primary key of the current journal article
6572            * @param groupId the group ID
6573            * @param articleId the article ID
6574            * @param status the status
6575            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6576            * @return the previous, current, and next journal article
6577            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6578            * @throws SystemException if a system exception occurred
6579            */
6580            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
6581                    long id, long groupId, java.lang.String articleId, int status,
6582                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6583                    throws com.liferay.portal.kernel.exception.SystemException,
6584                            com.liferay.portlet.journal.NoSuchArticleException {
6585                    return getPersistence()
6586                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
6587                            orderByComparator);
6588            }
6589    
6590            /**
6591            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6592            *
6593            * @param groupId the group ID
6594            * @param articleId the article ID
6595            * @param status the status
6596            * @return the matching journal articles that the user has permission to view
6597            * @throws SystemException if a system exception occurred
6598            */
6599            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6600                    long groupId, java.lang.String articleId, int status)
6601                    throws com.liferay.portal.kernel.exception.SystemException {
6602                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
6603            }
6604    
6605            /**
6606            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6607            *
6608            * <p>
6609            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6610            * </p>
6611            *
6612            * @param groupId the group ID
6613            * @param articleId the article ID
6614            * @param status the status
6615            * @param start the lower bound of the range of journal articles
6616            * @param end the upper bound of the range of journal articles (not inclusive)
6617            * @return the range of matching journal articles that the user has permission to view
6618            * @throws SystemException if a system exception occurred
6619            */
6620            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6621                    long groupId, java.lang.String articleId, int status, int start, int end)
6622                    throws com.liferay.portal.kernel.exception.SystemException {
6623                    return getPersistence()
6624                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
6625            }
6626    
6627            /**
6628            * 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;.
6629            *
6630            * <p>
6631            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6632            * </p>
6633            *
6634            * @param groupId the group ID
6635            * @param articleId the article ID
6636            * @param status the status
6637            * @param start the lower bound of the range of journal articles
6638            * @param end the upper bound of the range of journal articles (not inclusive)
6639            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6640            * @return the ordered range of matching journal articles that the user has permission to view
6641            * @throws SystemException if a system exception occurred
6642            */
6643            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6644                    long groupId, java.lang.String articleId, int status, int start,
6645                    int end,
6646                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6647                    throws com.liferay.portal.kernel.exception.SystemException {
6648                    return getPersistence()
6649                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
6650                            orderByComparator);
6651            }
6652    
6653            /**
6654            * 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;.
6655            *
6656            * @param id the primary key of the current journal article
6657            * @param groupId the group ID
6658            * @param articleId the article ID
6659            * @param status the status
6660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6661            * @return the previous, current, and next journal article
6662            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6663            * @throws SystemException if a system exception occurred
6664            */
6665            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
6666                    long id, long groupId, java.lang.String articleId, int status,
6667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6668                    throws com.liferay.portal.kernel.exception.SystemException,
6669                            com.liferay.portlet.journal.NoSuchArticleException {
6670                    return getPersistence()
6671                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
6672                            status, orderByComparator);
6673            }
6674    
6675            /**
6676            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6677            *
6678            * @param groupId the group ID
6679            * @param articleId the article ID
6680            * @param statuses the statuses
6681            * @return the matching journal articles that the user has permission to view
6682            * @throws SystemException if a system exception occurred
6683            */
6684            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6685                    long groupId, java.lang.String articleId, int[] statuses)
6686                    throws com.liferay.portal.kernel.exception.SystemException {
6687                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
6688            }
6689    
6690            /**
6691            * 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;.
6692            *
6693            * <p>
6694            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6695            * </p>
6696            *
6697            * @param groupId the group ID
6698            * @param articleId the article ID
6699            * @param statuses the statuses
6700            * @param start the lower bound of the range of journal articles
6701            * @param end the upper bound of the range of journal articles (not inclusive)
6702            * @return the range of matching journal articles that the user has permission to view
6703            * @throws SystemException if a system exception occurred
6704            */
6705            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6706                    long groupId, java.lang.String articleId, int[] statuses, int start,
6707                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6708                    return getPersistence()
6709                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
6710            }
6711    
6712            /**
6713            * 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;.
6714            *
6715            * <p>
6716            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6717            * </p>
6718            *
6719            * @param groupId the group ID
6720            * @param articleId the article ID
6721            * @param statuses the statuses
6722            * @param start the lower bound of the range of journal articles
6723            * @param end the upper bound of the range of journal articles (not inclusive)
6724            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6725            * @return the ordered range of matching journal articles that the user has permission to view
6726            * @throws SystemException if a system exception occurred
6727            */
6728            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6729                    long groupId, java.lang.String articleId, int[] statuses, int start,
6730                    int end,
6731                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6732                    throws com.liferay.portal.kernel.exception.SystemException {
6733                    return getPersistence()
6734                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
6735                            end, orderByComparator);
6736            }
6737    
6738            /**
6739            * Returns all the journal articles where groupId = &#63; and articleId = &#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 articleId the article ID
6747            * @param statuses the statuses
6748            * @return the matching journal articles
6749            * @throws SystemException if a system exception occurred
6750            */
6751            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6752                    long groupId, java.lang.String articleId, int[] statuses)
6753                    throws com.liferay.portal.kernel.exception.SystemException {
6754                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
6755            }
6756    
6757            /**
6758            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6759            *
6760            * <p>
6761            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6762            * </p>
6763            *
6764            * @param groupId the group ID
6765            * @param articleId the article ID
6766            * @param statuses the statuses
6767            * @param start the lower bound of the range of journal articles
6768            * @param end the upper bound of the range of journal articles (not inclusive)
6769            * @return the range of matching journal articles
6770            * @throws SystemException if a system exception occurred
6771            */
6772            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6773                    long groupId, java.lang.String articleId, int[] statuses, int start,
6774                    int end) throws com.liferay.portal.kernel.exception.SystemException {
6775                    return getPersistence()
6776                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
6777            }
6778    
6779            /**
6780            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6781            *
6782            * <p>
6783            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6784            * </p>
6785            *
6786            * @param groupId the group ID
6787            * @param articleId the article ID
6788            * @param statuses the statuses
6789            * @param start the lower bound of the range of journal articles
6790            * @param end the upper bound of the range of journal articles (not inclusive)
6791            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6792            * @return the ordered range of matching journal articles
6793            * @throws SystemException if a system exception occurred
6794            */
6795            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6796                    long groupId, java.lang.String articleId, int[] statuses, int start,
6797                    int end,
6798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6799                    throws com.liferay.portal.kernel.exception.SystemException {
6800                    return getPersistence()
6801                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
6802                            orderByComparator);
6803            }
6804    
6805            /**
6806            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
6807            *
6808            * @param groupId the group ID
6809            * @param articleId the article ID
6810            * @param status the status
6811            * @throws SystemException if a system exception occurred
6812            */
6813            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
6814                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6815                    getPersistence().removeByG_A_ST(groupId, articleId, status);
6816            }
6817    
6818            /**
6819            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6820            *
6821            * @param groupId the group ID
6822            * @param articleId the article ID
6823            * @param status the status
6824            * @return the number of matching journal articles
6825            * @throws SystemException if a system exception occurred
6826            */
6827            public static int countByG_A_ST(long groupId, java.lang.String articleId,
6828                    int status) throws com.liferay.portal.kernel.exception.SystemException {
6829                    return getPersistence().countByG_A_ST(groupId, articleId, status);
6830            }
6831    
6832            /**
6833            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6834            *
6835            * @param groupId the group ID
6836            * @param articleId the article ID
6837            * @param statuses the statuses
6838            * @return the number of matching journal articles
6839            * @throws SystemException if a system exception occurred
6840            */
6841            public static int countByG_A_ST(long groupId, java.lang.String articleId,
6842                    int[] statuses)
6843                    throws com.liferay.portal.kernel.exception.SystemException {
6844                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
6845            }
6846    
6847            /**
6848            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6849            *
6850            * @param groupId the group ID
6851            * @param articleId the article ID
6852            * @param status the status
6853            * @return the number of matching journal articles that the user has permission to view
6854            * @throws SystemException if a system exception occurred
6855            */
6856            public static int filterCountByG_A_ST(long groupId,
6857                    java.lang.String articleId, int status)
6858                    throws com.liferay.portal.kernel.exception.SystemException {
6859                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
6860            }
6861    
6862            /**
6863            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6864            *
6865            * @param groupId the group ID
6866            * @param articleId the article ID
6867            * @param statuses the statuses
6868            * @return the number of matching journal articles that the user has permission to view
6869            * @throws SystemException if a system exception occurred
6870            */
6871            public static int filterCountByG_A_ST(long groupId,
6872                    java.lang.String articleId, int[] statuses)
6873                    throws com.liferay.portal.kernel.exception.SystemException {
6874                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
6875            }
6876    
6877            /**
6878            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6879            *
6880            * @param groupId the group ID
6881            * @param urlTitle the url title
6882            * @param status the status
6883            * @return the matching journal articles
6884            * @throws SystemException if a system exception occurred
6885            */
6886            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
6887                    long groupId, java.lang.String urlTitle, int status)
6888                    throws com.liferay.portal.kernel.exception.SystemException {
6889                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
6890            }
6891    
6892            /**
6893            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#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 urlTitle the url title
6901            * @param status the status
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            * @return the range of matching journal articles
6905            * @throws SystemException if a system exception occurred
6906            */
6907            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
6908                    long groupId, java.lang.String urlTitle, int status, int start, int end)
6909                    throws com.liferay.portal.kernel.exception.SystemException {
6910                    return getPersistence()
6911                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
6912            }
6913    
6914            /**
6915            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6916            *
6917            * <p>
6918            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6919            * </p>
6920            *
6921            * @param groupId the group ID
6922            * @param urlTitle the url title
6923            * @param status the status
6924            * @param start the lower bound of the range of journal articles
6925            * @param end the upper bound of the range of journal articles (not inclusive)
6926            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6927            * @return the ordered range of matching journal articles
6928            * @throws SystemException if a system exception occurred
6929            */
6930            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
6931                    long groupId, java.lang.String urlTitle, int status, int start,
6932                    int end,
6933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6934                    throws com.liferay.portal.kernel.exception.SystemException {
6935                    return getPersistence()
6936                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
6937                            orderByComparator);
6938            }
6939    
6940            /**
6941            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6942            *
6943            * @param groupId the group ID
6944            * @param urlTitle the url title
6945            * @param status the status
6946            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6947            * @return the first matching journal article
6948            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6949            * @throws SystemException if a system exception occurred
6950            */
6951            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
6952                    long groupId, java.lang.String urlTitle, int status,
6953                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6954                    throws com.liferay.portal.kernel.exception.SystemException,
6955                            com.liferay.portlet.journal.NoSuchArticleException {
6956                    return getPersistence()
6957                                       .findByG_UT_ST_First(groupId, urlTitle, status,
6958                            orderByComparator);
6959            }
6960    
6961            /**
6962            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6963            *
6964            * @param groupId the group ID
6965            * @param urlTitle the url title
6966            * @param status the status
6967            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6968            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6969            * @throws SystemException if a system exception occurred
6970            */
6971            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
6972                    long groupId, java.lang.String urlTitle, int status,
6973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6974                    throws com.liferay.portal.kernel.exception.SystemException {
6975                    return getPersistence()
6976                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
6977                            orderByComparator);
6978            }
6979    
6980            /**
6981            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6982            *
6983            * @param groupId the group ID
6984            * @param urlTitle the url title
6985            * @param status the status
6986            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6987            * @return the last matching journal article
6988            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6989            * @throws SystemException if a system exception occurred
6990            */
6991            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
6992                    long groupId, java.lang.String urlTitle, int status,
6993                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
6994                    throws com.liferay.portal.kernel.exception.SystemException,
6995                            com.liferay.portlet.journal.NoSuchArticleException {
6996                    return getPersistence()
6997                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
6998                            orderByComparator);
6999            }
7000    
7001            /**
7002            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7003            *
7004            * @param groupId the group ID
7005            * @param urlTitle the url title
7006            * @param status the status
7007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7008            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7009            * @throws SystemException if a system exception occurred
7010            */
7011            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
7012                    long groupId, java.lang.String urlTitle, int status,
7013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7014                    throws com.liferay.portal.kernel.exception.SystemException {
7015                    return getPersistence()
7016                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
7017                            orderByComparator);
7018            }
7019    
7020            /**
7021            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7022            *
7023            * @param id the primary key of the current journal article
7024            * @param groupId the group ID
7025            * @param urlTitle the url title
7026            * @param status the status
7027            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7028            * @return the previous, current, and next journal article
7029            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7030            * @throws SystemException if a system exception occurred
7031            */
7032            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
7033                    long id, long groupId, java.lang.String urlTitle, int status,
7034                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7035                    throws com.liferay.portal.kernel.exception.SystemException,
7036                            com.liferay.portlet.journal.NoSuchArticleException {
7037                    return getPersistence()
7038                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
7039                            orderByComparator);
7040            }
7041    
7042            /**
7043            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7044            *
7045            * @param groupId the group ID
7046            * @param urlTitle the url title
7047            * @param status the status
7048            * @return the matching journal articles that the user has permission to view
7049            * @throws SystemException if a system exception occurred
7050            */
7051            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7052                    long groupId, java.lang.String urlTitle, int status)
7053                    throws com.liferay.portal.kernel.exception.SystemException {
7054                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
7055            }
7056    
7057            /**
7058            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7059            *
7060            * <p>
7061            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7062            * </p>
7063            *
7064            * @param groupId the group ID
7065            * @param urlTitle the url title
7066            * @param status the status
7067            * @param start the lower bound of the range of journal articles
7068            * @param end the upper bound of the range of journal articles (not inclusive)
7069            * @return the 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_UT_ST(
7073                    long groupId, java.lang.String urlTitle, int status, int start, int end)
7074                    throws com.liferay.portal.kernel.exception.SystemException {
7075                    return getPersistence()
7076                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7077            }
7078    
7079            /**
7080            * 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;.
7081            *
7082            * <p>
7083            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7084            * </p>
7085            *
7086            * @param groupId the group ID
7087            * @param urlTitle the url title
7088            * @param status the status
7089            * @param start the lower bound of the range of journal articles
7090            * @param end the upper bound of the range of journal articles (not inclusive)
7091            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7092            * @return the ordered range of matching journal articles that the user has permission to view
7093            * @throws SystemException if a system exception occurred
7094            */
7095            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7096                    long groupId, java.lang.String urlTitle, int status, int start,
7097                    int end,
7098                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7099                    throws com.liferay.portal.kernel.exception.SystemException {
7100                    return getPersistence()
7101                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7102                            orderByComparator);
7103            }
7104    
7105            /**
7106            * 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;.
7107            *
7108            * @param id the primary key of the current journal article
7109            * @param groupId the group ID
7110            * @param urlTitle the url title
7111            * @param status the status
7112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7113            * @return the previous, current, and next journal article
7114            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7115            * @throws SystemException if a system exception occurred
7116            */
7117            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
7118                    long id, long groupId, java.lang.String urlTitle, int status,
7119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7120                    throws com.liferay.portal.kernel.exception.SystemException,
7121                            com.liferay.portlet.journal.NoSuchArticleException {
7122                    return getPersistence()
7123                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7124                            status, orderByComparator);
7125            }
7126    
7127            /**
7128            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7129            *
7130            * @param groupId the group ID
7131            * @param urlTitle the url title
7132            * @param status the status
7133            * @throws SystemException if a system exception occurred
7134            */
7135            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7136                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7137                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7138            }
7139    
7140            /**
7141            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7142            *
7143            * @param groupId the group ID
7144            * @param urlTitle the url title
7145            * @param status the status
7146            * @return the number of matching journal articles
7147            * @throws SystemException if a system exception occurred
7148            */
7149            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7150                    int status) throws com.liferay.portal.kernel.exception.SystemException {
7151                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7152            }
7153    
7154            /**
7155            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7156            *
7157            * @param groupId the group ID
7158            * @param urlTitle the url title
7159            * @param status the status
7160            * @return the number of matching journal articles that the user has permission to view
7161            * @throws SystemException if a system exception occurred
7162            */
7163            public static int filterCountByG_UT_ST(long groupId,
7164                    java.lang.String urlTitle, int status)
7165                    throws com.liferay.portal.kernel.exception.SystemException {
7166                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7167            }
7168    
7169            /**
7170            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7171            *
7172            * @param companyId the company ID
7173            * @param version the version
7174            * @param status the status
7175            * @return the matching journal articles
7176            * @throws SystemException if a system exception occurred
7177            */
7178            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7179                    long companyId, double version, int status)
7180                    throws com.liferay.portal.kernel.exception.SystemException {
7181                    return getPersistence().findByC_V_ST(companyId, version, status);
7182            }
7183    
7184            /**
7185            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7186            *
7187            * <p>
7188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7189            * </p>
7190            *
7191            * @param companyId the company ID
7192            * @param version the version
7193            * @param status the status
7194            * @param start the lower bound of the range of journal articles
7195            * @param end the upper bound of the range of journal articles (not inclusive)
7196            * @return the range of matching journal articles
7197            * @throws SystemException if a system exception occurred
7198            */
7199            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7200                    long companyId, double version, int status, int start, int end)
7201                    throws com.liferay.portal.kernel.exception.SystemException {
7202                    return getPersistence()
7203                                       .findByC_V_ST(companyId, version, status, start, end);
7204            }
7205    
7206            /**
7207            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7208            *
7209            * <p>
7210            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7211            * </p>
7212            *
7213            * @param companyId the company ID
7214            * @param version the version
7215            * @param status the status
7216            * @param start the lower bound of the range of journal articles
7217            * @param end the upper bound of the range of journal articles (not inclusive)
7218            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7219            * @return the ordered range of matching journal articles
7220            * @throws SystemException if a system exception occurred
7221            */
7222            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7223                    long companyId, double version, int status, int start, int end,
7224                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7225                    throws com.liferay.portal.kernel.exception.SystemException {
7226                    return getPersistence()
7227                                       .findByC_V_ST(companyId, version, status, start, end,
7228                            orderByComparator);
7229            }
7230    
7231            /**
7232            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7233            *
7234            * @param companyId the company ID
7235            * @param version the version
7236            * @param status the status
7237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7238            * @return the first matching journal article
7239            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7240            * @throws SystemException if a system exception occurred
7241            */
7242            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
7243                    long companyId, double version, int status,
7244                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7245                    throws com.liferay.portal.kernel.exception.SystemException,
7246                            com.liferay.portlet.journal.NoSuchArticleException {
7247                    return getPersistence()
7248                                       .findByC_V_ST_First(companyId, version, status,
7249                            orderByComparator);
7250            }
7251    
7252            /**
7253            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7254            *
7255            * @param companyId the company ID
7256            * @param version the version
7257            * @param status the status
7258            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7259            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7260            * @throws SystemException if a system exception occurred
7261            */
7262            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
7263                    long companyId, double version, int status,
7264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7265                    throws com.liferay.portal.kernel.exception.SystemException {
7266                    return getPersistence()
7267                                       .fetchByC_V_ST_First(companyId, version, status,
7268                            orderByComparator);
7269            }
7270    
7271            /**
7272            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7273            *
7274            * @param companyId the company ID
7275            * @param version the version
7276            * @param status the status
7277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7278            * @return the last matching journal article
7279            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7280            * @throws SystemException if a system exception occurred
7281            */
7282            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
7283                    long companyId, double version, int status,
7284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7285                    throws com.liferay.portal.kernel.exception.SystemException,
7286                            com.liferay.portlet.journal.NoSuchArticleException {
7287                    return getPersistence()
7288                                       .findByC_V_ST_Last(companyId, version, status,
7289                            orderByComparator);
7290            }
7291    
7292            /**
7293            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7294            *
7295            * @param companyId the company ID
7296            * @param version the version
7297            * @param status the status
7298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7299            * @return the last matching journal article, or <code>null</code> 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 fetchByC_V_ST_Last(
7303                    long companyId, double version, int status,
7304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7305                    throws com.liferay.portal.kernel.exception.SystemException {
7306                    return getPersistence()
7307                                       .fetchByC_V_ST_Last(companyId, version, status,
7308                            orderByComparator);
7309            }
7310    
7311            /**
7312            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7313            *
7314            * @param id the primary key of the current journal article
7315            * @param companyId the company ID
7316            * @param version the version
7317            * @param status the status
7318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7319            * @return the previous, current, and next journal article
7320            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7321            * @throws SystemException if a system exception occurred
7322            */
7323            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
7324                    long id, long companyId, double version, int status,
7325                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7326                    throws com.liferay.portal.kernel.exception.SystemException,
7327                            com.liferay.portlet.journal.NoSuchArticleException {
7328                    return getPersistence()
7329                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7330                            orderByComparator);
7331            }
7332    
7333            /**
7334            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7335            *
7336            * @param companyId the company ID
7337            * @param version the version
7338            * @param status the status
7339            * @throws SystemException if a system exception occurred
7340            */
7341            public static void removeByC_V_ST(long companyId, double version, int status)
7342                    throws com.liferay.portal.kernel.exception.SystemException {
7343                    getPersistence().removeByC_V_ST(companyId, version, status);
7344            }
7345    
7346            /**
7347            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7348            *
7349            * @param companyId the company ID
7350            * @param version the version
7351            * @param status the status
7352            * @return the number of matching journal articles
7353            * @throws SystemException if a system exception occurred
7354            */
7355            public static int countByC_V_ST(long companyId, double version, int status)
7356                    throws com.liferay.portal.kernel.exception.SystemException {
7357                    return getPersistence().countByC_V_ST(companyId, version, status);
7358            }
7359    
7360            /**
7361            * Caches the journal article in the entity cache if it is enabled.
7362            *
7363            * @param journalArticle the journal article
7364            */
7365            public static void cacheResult(
7366                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7367                    getPersistence().cacheResult(journalArticle);
7368            }
7369    
7370            /**
7371            * Caches the journal articles in the entity cache if it is enabled.
7372            *
7373            * @param journalArticles the journal articles
7374            */
7375            public static void cacheResult(
7376                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
7377                    getPersistence().cacheResult(journalArticles);
7378            }
7379    
7380            /**
7381            * Creates a new journal article with the primary key. Does not add the journal article to the database.
7382            *
7383            * @param id the primary key for the new journal article
7384            * @return the new journal article
7385            */
7386            public static com.liferay.portlet.journal.model.JournalArticle create(
7387                    long id) {
7388                    return getPersistence().create(id);
7389            }
7390    
7391            /**
7392            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
7393            *
7394            * @param id the primary key of the journal article
7395            * @return the journal article that was removed
7396            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7397            * @throws SystemException if a system exception occurred
7398            */
7399            public static com.liferay.portlet.journal.model.JournalArticle remove(
7400                    long id)
7401                    throws com.liferay.portal.kernel.exception.SystemException,
7402                            com.liferay.portlet.journal.NoSuchArticleException {
7403                    return getPersistence().remove(id);
7404            }
7405    
7406            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
7407                    com.liferay.portlet.journal.model.JournalArticle journalArticle)
7408                    throws com.liferay.portal.kernel.exception.SystemException {
7409                    return getPersistence().updateImpl(journalArticle);
7410            }
7411    
7412            /**
7413            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
7414            *
7415            * @param id the primary key of the journal article
7416            * @return the journal article
7417            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7418            * @throws SystemException if a system exception occurred
7419            */
7420            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
7421                    long id)
7422                    throws com.liferay.portal.kernel.exception.SystemException,
7423                            com.liferay.portlet.journal.NoSuchArticleException {
7424                    return getPersistence().findByPrimaryKey(id);
7425            }
7426    
7427            /**
7428            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
7429            *
7430            * @param id the primary key of the journal article
7431            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
7432            * @throws SystemException if a system exception occurred
7433            */
7434            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
7435                    long id) throws com.liferay.portal.kernel.exception.SystemException {
7436                    return getPersistence().fetchByPrimaryKey(id);
7437            }
7438    
7439            /**
7440            * Returns all the journal articles.
7441            *
7442            * @return the journal articles
7443            * @throws SystemException if a system exception occurred
7444            */
7445            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
7446                    throws com.liferay.portal.kernel.exception.SystemException {
7447                    return getPersistence().findAll();
7448            }
7449    
7450            /**
7451            * Returns a range of all the journal articles.
7452            *
7453            * <p>
7454            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7455            * </p>
7456            *
7457            * @param start the lower bound of the range of journal articles
7458            * @param end the upper bound of the range of journal articles (not inclusive)
7459            * @return the range of journal articles
7460            * @throws SystemException if a system exception occurred
7461            */
7462            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7463                    int start, int end)
7464                    throws com.liferay.portal.kernel.exception.SystemException {
7465                    return getPersistence().findAll(start, end);
7466            }
7467    
7468            /**
7469            * Returns an ordered range of all the journal articles.
7470            *
7471            * <p>
7472            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
7473            * </p>
7474            *
7475            * @param start the lower bound of the range of journal articles
7476            * @param end the upper bound of the range of journal articles (not inclusive)
7477            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7478            * @return the ordered range of journal articles
7479            * @throws SystemException if a system exception occurred
7480            */
7481            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7482                    int start, int end,
7483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
7484                    throws com.liferay.portal.kernel.exception.SystemException {
7485                    return getPersistence().findAll(start, end, orderByComparator);
7486            }
7487    
7488            /**
7489            * Removes all the journal articles from the database.
7490            *
7491            * @throws SystemException if a system exception occurred
7492            */
7493            public static void removeAll()
7494                    throws com.liferay.portal.kernel.exception.SystemException {
7495                    getPersistence().removeAll();
7496            }
7497    
7498            /**
7499            * Returns the number of journal articles.
7500            *
7501            * @return the number of journal articles
7502            * @throws SystemException if a system exception occurred
7503            */
7504            public static int countAll()
7505                    throws com.liferay.portal.kernel.exception.SystemException {
7506                    return getPersistence().countAll();
7507            }
7508    
7509            public static JournalArticlePersistence getPersistence() {
7510                    if (_persistence == null) {
7511                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
7512    
7513                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
7514                                    "_persistence");
7515                    }
7516    
7517                    return _persistence;
7518            }
7519    
7520            /**
7521             * @deprecated As of 6.2.0
7522             */
7523            public void setPersistence(JournalArticlePersistence persistence) {
7524            }
7525    
7526            private static JournalArticlePersistence _persistence;
7527    }