001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.journal.model.JournalArticle;
022    
023    /**
024     * The persistence interface for the journal article service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.journal.service.persistence.impl.JournalArticlePersistenceImpl
032     * @see JournalArticleUtil
033     * @generated
034     */
035    @ProviderType
036    public interface JournalArticlePersistence extends BasePersistence<JournalArticle> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link JournalArticleUtil} to access the journal article persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the journal articles where uuid = &#63;.
045            *
046            * @param uuid the uuid
047            * @return the matching journal articles
048            */
049            public java.util.List<JournalArticle> findByUuid(java.lang.String uuid);
050    
051            /**
052            * Returns a range of all the journal articles where uuid = &#63;.
053            *
054            * <p>
055            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
056            * </p>
057            *
058            * @param uuid the uuid
059            * @param start the lower bound of the range of journal articles
060            * @param end the upper bound of the range of journal articles (not inclusive)
061            * @return the range of matching journal articles
062            */
063            public java.util.List<JournalArticle> findByUuid(java.lang.String uuid,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the journal articles where uuid = &#63;.
068            *
069            * <p>
070            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
071            * </p>
072            *
073            * @param uuid the uuid
074            * @param start the lower bound of the range of journal articles
075            * @param end the upper bound of the range of journal articles (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching journal articles
078            */
079            public java.util.List<JournalArticle> findByUuid(java.lang.String uuid,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
082    
083            /**
084            * Returns the first journal article in the ordered set where uuid = &#63;.
085            *
086            * @param uuid the uuid
087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
088            * @return the first matching journal article
089            * @throws NoSuchArticleException if a matching journal article could not be found
090            */
091            public JournalArticle findByUuid_First(java.lang.String uuid,
092                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
093                    throws com.liferay.portlet.journal.NoSuchArticleException;
094    
095            /**
096            * Returns the first journal article in the ordered set where uuid = &#63;.
097            *
098            * @param uuid the uuid
099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
100            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
101            */
102            public JournalArticle fetchByUuid_First(java.lang.String uuid,
103                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
104    
105            /**
106            * Returns the last journal article in the ordered set where uuid = &#63;.
107            *
108            * @param uuid the uuid
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the last matching journal article
111            * @throws NoSuchArticleException if a matching journal article could not be found
112            */
113            public JournalArticle findByUuid_Last(java.lang.String uuid,
114                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
115                    throws com.liferay.portlet.journal.NoSuchArticleException;
116    
117            /**
118            * Returns the last journal article in the ordered set where uuid = &#63;.
119            *
120            * @param uuid the uuid
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
123            */
124            public JournalArticle fetchByUuid_Last(java.lang.String uuid,
125                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
126    
127            /**
128            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
129            *
130            * @param id the primary key of the current journal article
131            * @param uuid the uuid
132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
133            * @return the previous, current, and next journal article
134            * @throws NoSuchArticleException if a journal article with the primary key could not be found
135            */
136            public JournalArticle[] findByUuid_PrevAndNext(long id,
137                    java.lang.String uuid,
138                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
139                    throws com.liferay.portlet.journal.NoSuchArticleException;
140    
141            /**
142            * Removes all the journal articles where uuid = &#63; from the database.
143            *
144            * @param uuid the uuid
145            */
146            public void removeByUuid(java.lang.String uuid);
147    
148            /**
149            * Returns the number of journal articles where uuid = &#63;.
150            *
151            * @param uuid the uuid
152            * @return the number of matching journal articles
153            */
154            public int countByUuid(java.lang.String uuid);
155    
156            /**
157            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchArticleException} if it could not be found.
158            *
159            * @param uuid the uuid
160            * @param groupId the group ID
161            * @return the matching journal article
162            * @throws NoSuchArticleException if a matching journal article could not be found
163            */
164            public JournalArticle findByUUID_G(java.lang.String uuid, long groupId)
165                    throws com.liferay.portlet.journal.NoSuchArticleException;
166    
167            /**
168            * 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.
169            *
170            * @param uuid the uuid
171            * @param groupId the group ID
172            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
173            */
174            public JournalArticle fetchByUUID_G(java.lang.String uuid, long groupId);
175    
176            /**
177            * 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.
178            *
179            * @param uuid the uuid
180            * @param groupId the group ID
181            * @param retrieveFromCache whether to use the finder cache
182            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
183            */
184            public JournalArticle fetchByUUID_G(java.lang.String uuid, long groupId,
185                    boolean retrieveFromCache);
186    
187            /**
188            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
189            *
190            * @param uuid the uuid
191            * @param groupId the group ID
192            * @return the journal article that was removed
193            */
194            public JournalArticle removeByUUID_G(java.lang.String uuid, long groupId)
195                    throws com.liferay.portlet.journal.NoSuchArticleException;
196    
197            /**
198            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
199            *
200            * @param uuid the uuid
201            * @param groupId the group ID
202            * @return the number of matching journal articles
203            */
204            public int countByUUID_G(java.lang.String uuid, long groupId);
205    
206            /**
207            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
208            *
209            * @param uuid the uuid
210            * @param companyId the company ID
211            * @return the matching journal articles
212            */
213            public java.util.List<JournalArticle> findByUuid_C(java.lang.String uuid,
214                    long companyId);
215    
216            /**
217            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
218            *
219            * <p>
220            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
221            * </p>
222            *
223            * @param uuid the uuid
224            * @param companyId the company ID
225            * @param start the lower bound of the range of journal articles
226            * @param end the upper bound of the range of journal articles (not inclusive)
227            * @return the range of matching journal articles
228            */
229            public java.util.List<JournalArticle> findByUuid_C(java.lang.String uuid,
230                    long companyId, int start, int end);
231    
232            /**
233            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
234            *
235            * <p>
236            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
237            * </p>
238            *
239            * @param uuid the uuid
240            * @param companyId the company ID
241            * @param start the lower bound of the range of journal articles
242            * @param end the upper bound of the range of journal articles (not inclusive)
243            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
244            * @return the ordered range of matching journal articles
245            */
246            public java.util.List<JournalArticle> findByUuid_C(java.lang.String uuid,
247                    long companyId, int start, int end,
248                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
249    
250            /**
251            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
252            *
253            * @param uuid the uuid
254            * @param companyId the company ID
255            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
256            * @return the first matching journal article
257            * @throws NoSuchArticleException if a matching journal article could not be found
258            */
259            public JournalArticle findByUuid_C_First(java.lang.String uuid,
260                    long companyId,
261                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
262                    throws com.liferay.portlet.journal.NoSuchArticleException;
263    
264            /**
265            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
266            *
267            * @param uuid the uuid
268            * @param companyId the company ID
269            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
270            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
271            */
272            public JournalArticle fetchByUuid_C_First(java.lang.String uuid,
273                    long companyId,
274                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
275    
276            /**
277            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
278            *
279            * @param uuid the uuid
280            * @param companyId the company ID
281            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
282            * @return the last matching journal article
283            * @throws NoSuchArticleException if a matching journal article could not be found
284            */
285            public JournalArticle findByUuid_C_Last(java.lang.String uuid,
286                    long companyId,
287                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
288                    throws com.liferay.portlet.journal.NoSuchArticleException;
289    
290            /**
291            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
292            *
293            * @param uuid the uuid
294            * @param companyId the company ID
295            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
296            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
297            */
298            public JournalArticle fetchByUuid_C_Last(java.lang.String uuid,
299                    long companyId,
300                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
301    
302            /**
303            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
304            *
305            * @param id the primary key of the current journal article
306            * @param uuid the uuid
307            * @param companyId the company ID
308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
309            * @return the previous, current, and next journal article
310            * @throws NoSuchArticleException if a journal article with the primary key could not be found
311            */
312            public JournalArticle[] findByUuid_C_PrevAndNext(long id,
313                    java.lang.String uuid, long companyId,
314                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
315                    throws com.liferay.portlet.journal.NoSuchArticleException;
316    
317            /**
318            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param companyId the company ID
322            */
323            public void removeByUuid_C(java.lang.String uuid, long companyId);
324    
325            /**
326            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
327            *
328            * @param uuid the uuid
329            * @param companyId the company ID
330            * @return the number of matching journal articles
331            */
332            public int countByUuid_C(java.lang.String uuid, long companyId);
333    
334            /**
335            * Returns all the journal articles where resourcePrimKey = &#63;.
336            *
337            * @param resourcePrimKey the resource prim key
338            * @return the matching journal articles
339            */
340            public java.util.List<JournalArticle> findByResourcePrimKey(
341                    long resourcePrimKey);
342    
343            /**
344            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
345            *
346            * <p>
347            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
348            * </p>
349            *
350            * @param resourcePrimKey the resource prim key
351            * @param start the lower bound of the range of journal articles
352            * @param end the upper bound of the range of journal articles (not inclusive)
353            * @return the range of matching journal articles
354            */
355            public java.util.List<JournalArticle> findByResourcePrimKey(
356                    long resourcePrimKey, int start, int end);
357    
358            /**
359            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
360            *
361            * <p>
362            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
363            * </p>
364            *
365            * @param resourcePrimKey the resource prim key
366            * @param start the lower bound of the range of journal articles
367            * @param end the upper bound of the range of journal articles (not inclusive)
368            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
369            * @return the ordered range of matching journal articles
370            */
371            public java.util.List<JournalArticle> findByResourcePrimKey(
372                    long resourcePrimKey, int start, int end,
373                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
374    
375            /**
376            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
377            *
378            * @param resourcePrimKey the resource prim key
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the first matching journal article
381            * @throws NoSuchArticleException if a matching journal article could not be found
382            */
383            public JournalArticle findByResourcePrimKey_First(long resourcePrimKey,
384                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
385                    throws com.liferay.portlet.journal.NoSuchArticleException;
386    
387            /**
388            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
389            *
390            * @param resourcePrimKey the resource prim key
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
393            */
394            public JournalArticle fetchByResourcePrimKey_First(long resourcePrimKey,
395                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
396    
397            /**
398            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
399            *
400            * @param resourcePrimKey the resource prim key
401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
402            * @return the last matching journal article
403            * @throws NoSuchArticleException if a matching journal article could not be found
404            */
405            public JournalArticle findByResourcePrimKey_Last(long resourcePrimKey,
406                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
407                    throws com.liferay.portlet.journal.NoSuchArticleException;
408    
409            /**
410            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
411            *
412            * @param resourcePrimKey the resource prim key
413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
414            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
415            */
416            public JournalArticle fetchByResourcePrimKey_Last(long resourcePrimKey,
417                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
418    
419            /**
420            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
421            *
422            * @param id the primary key of the current journal article
423            * @param resourcePrimKey the resource prim key
424            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
425            * @return the previous, current, and next journal article
426            * @throws NoSuchArticleException if a journal article with the primary key could not be found
427            */
428            public JournalArticle[] findByResourcePrimKey_PrevAndNext(long id,
429                    long resourcePrimKey,
430                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
431                    throws com.liferay.portlet.journal.NoSuchArticleException;
432    
433            /**
434            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
435            *
436            * @param resourcePrimKey the resource prim key
437            */
438            public void removeByResourcePrimKey(long resourcePrimKey);
439    
440            /**
441            * Returns the number of journal articles where resourcePrimKey = &#63;.
442            *
443            * @param resourcePrimKey the resource prim key
444            * @return the number of matching journal articles
445            */
446            public int countByResourcePrimKey(long resourcePrimKey);
447    
448            /**
449            * Returns all the journal articles where groupId = &#63;.
450            *
451            * @param groupId the group ID
452            * @return the matching journal articles
453            */
454            public java.util.List<JournalArticle> findByGroupId(long groupId);
455    
456            /**
457            * Returns a range of all the journal articles where groupId = &#63;.
458            *
459            * <p>
460            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
461            * </p>
462            *
463            * @param groupId the group ID
464            * @param start the lower bound of the range of journal articles
465            * @param end the upper bound of the range of journal articles (not inclusive)
466            * @return the range of matching journal articles
467            */
468            public java.util.List<JournalArticle> findByGroupId(long groupId,
469                    int start, int end);
470    
471            /**
472            * Returns an ordered range of all the journal articles where groupId = &#63;.
473            *
474            * <p>
475            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
476            * </p>
477            *
478            * @param groupId the group ID
479            * @param start the lower bound of the range of journal articles
480            * @param end the upper bound of the range of journal articles (not inclusive)
481            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
482            * @return the ordered range of matching journal articles
483            */
484            public java.util.List<JournalArticle> findByGroupId(long groupId,
485                    int start, int end,
486                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
487    
488            /**
489            * Returns the first journal article in the ordered set where groupId = &#63;.
490            *
491            * @param groupId the group ID
492            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
493            * @return the first matching journal article
494            * @throws NoSuchArticleException if a matching journal article could not be found
495            */
496            public JournalArticle findByGroupId_First(long groupId,
497                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
498                    throws com.liferay.portlet.journal.NoSuchArticleException;
499    
500            /**
501            * Returns the first journal article in the ordered set where groupId = &#63;.
502            *
503            * @param groupId the group ID
504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
505            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
506            */
507            public JournalArticle fetchByGroupId_First(long groupId,
508                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
509    
510            /**
511            * Returns the last journal article in the ordered set where groupId = &#63;.
512            *
513            * @param groupId the group ID
514            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
515            * @return the last matching journal article
516            * @throws NoSuchArticleException if a matching journal article could not be found
517            */
518            public JournalArticle findByGroupId_Last(long groupId,
519                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
520                    throws com.liferay.portlet.journal.NoSuchArticleException;
521    
522            /**
523            * Returns the last journal article in the ordered set where groupId = &#63;.
524            *
525            * @param groupId the group ID
526            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
527            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
528            */
529            public JournalArticle fetchByGroupId_Last(long groupId,
530                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
531    
532            /**
533            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
534            *
535            * @param id the primary key of the current journal article
536            * @param groupId the group ID
537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
538            * @return the previous, current, and next journal article
539            * @throws NoSuchArticleException if a journal article with the primary key could not be found
540            */
541            public JournalArticle[] findByGroupId_PrevAndNext(long id, long groupId,
542                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
543                    throws com.liferay.portlet.journal.NoSuchArticleException;
544    
545            /**
546            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
547            *
548            * @param groupId the group ID
549            * @return the matching journal articles that the user has permission to view
550            */
551            public java.util.List<JournalArticle> filterFindByGroupId(long groupId);
552    
553            /**
554            * Returns a range of all the journal articles that the user has permission to view where groupId = &#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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID
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            * @return the range of matching journal articles that the user has permission to view
564            */
565            public java.util.List<JournalArticle> filterFindByGroupId(long groupId,
566                    int start, int end);
567    
568            /**
569            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
570            *
571            * <p>
572            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
573            * </p>
574            *
575            * @param groupId the group ID
576            * @param start the lower bound of the range of journal articles
577            * @param end the upper bound of the range of journal articles (not inclusive)
578            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
579            * @return the ordered range of matching journal articles that the user has permission to view
580            */
581            public java.util.List<JournalArticle> filterFindByGroupId(long groupId,
582                    int start, int end,
583                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
584    
585            /**
586            * 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;.
587            *
588            * @param id the primary key of the current journal article
589            * @param groupId the group ID
590            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
591            * @return the previous, current, and next journal article
592            * @throws NoSuchArticleException if a journal article with the primary key could not be found
593            */
594            public JournalArticle[] filterFindByGroupId_PrevAndNext(long id,
595                    long groupId,
596                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
597                    throws com.liferay.portlet.journal.NoSuchArticleException;
598    
599            /**
600            * Removes all the journal articles where groupId = &#63; from the database.
601            *
602            * @param groupId the group ID
603            */
604            public void removeByGroupId(long groupId);
605    
606            /**
607            * Returns the number of journal articles where groupId = &#63;.
608            *
609            * @param groupId the group ID
610            * @return the number of matching journal articles
611            */
612            public int countByGroupId(long groupId);
613    
614            /**
615            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
616            *
617            * @param groupId the group ID
618            * @return the number of matching journal articles that the user has permission to view
619            */
620            public int filterCountByGroupId(long groupId);
621    
622            /**
623            * Returns all the journal articles where companyId = &#63;.
624            *
625            * @param companyId the company ID
626            * @return the matching journal articles
627            */
628            public java.util.List<JournalArticle> findByCompanyId(long companyId);
629    
630            /**
631            * Returns a range of all the journal articles where companyId = &#63;.
632            *
633            * <p>
634            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
635            * </p>
636            *
637            * @param companyId the company ID
638            * @param start the lower bound of the range of journal articles
639            * @param end the upper bound of the range of journal articles (not inclusive)
640            * @return the range of matching journal articles
641            */
642            public java.util.List<JournalArticle> findByCompanyId(long companyId,
643                    int start, int end);
644    
645            /**
646            * Returns an ordered range of all the journal articles where companyId = &#63;.
647            *
648            * <p>
649            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
650            * </p>
651            *
652            * @param companyId the company ID
653            * @param start the lower bound of the range of journal articles
654            * @param end the upper bound of the range of journal articles (not inclusive)
655            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
656            * @return the ordered range of matching journal articles
657            */
658            public java.util.List<JournalArticle> findByCompanyId(long companyId,
659                    int start, int end,
660                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
661    
662            /**
663            * Returns the first journal article in the ordered set where companyId = &#63;.
664            *
665            * @param companyId the company ID
666            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
667            * @return the first matching journal article
668            * @throws NoSuchArticleException if a matching journal article could not be found
669            */
670            public JournalArticle findByCompanyId_First(long companyId,
671                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
672                    throws com.liferay.portlet.journal.NoSuchArticleException;
673    
674            /**
675            * Returns the first journal article in the ordered set where companyId = &#63;.
676            *
677            * @param companyId the company ID
678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
679            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
680            */
681            public JournalArticle fetchByCompanyId_First(long companyId,
682                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
683    
684            /**
685            * Returns the last journal article in the ordered set where companyId = &#63;.
686            *
687            * @param companyId the company ID
688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
689            * @return the last matching journal article
690            * @throws NoSuchArticleException if a matching journal article could not be found
691            */
692            public JournalArticle findByCompanyId_Last(long companyId,
693                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
694                    throws com.liferay.portlet.journal.NoSuchArticleException;
695    
696            /**
697            * Returns the last journal article in the ordered set where companyId = &#63;.
698            *
699            * @param companyId the company ID
700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
701            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
702            */
703            public JournalArticle fetchByCompanyId_Last(long companyId,
704                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
705    
706            /**
707            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
708            *
709            * @param id the primary key of the current journal article
710            * @param companyId the company ID
711            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
712            * @return the previous, current, and next journal article
713            * @throws NoSuchArticleException if a journal article with the primary key could not be found
714            */
715            public JournalArticle[] findByCompanyId_PrevAndNext(long id,
716                    long companyId,
717                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
718                    throws com.liferay.portlet.journal.NoSuchArticleException;
719    
720            /**
721            * Removes all the journal articles where companyId = &#63; from the database.
722            *
723            * @param companyId the company ID
724            */
725            public void removeByCompanyId(long companyId);
726    
727            /**
728            * Returns the number of journal articles where companyId = &#63;.
729            *
730            * @param companyId the company ID
731            * @return the number of matching journal articles
732            */
733            public int countByCompanyId(long companyId);
734    
735            /**
736            * Returns all the journal articles where DDMStructureKey = &#63;.
737            *
738            * @param DDMStructureKey the d d m structure key
739            * @return the matching journal articles
740            */
741            public java.util.List<JournalArticle> findByDDMStructureKey(
742                    java.lang.String DDMStructureKey);
743    
744            /**
745            * Returns a range of all the journal articles where DDMStructureKey = &#63;.
746            *
747            * <p>
748            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
749            * </p>
750            *
751            * @param DDMStructureKey the d d m structure key
752            * @param start the lower bound of the range of journal articles
753            * @param end the upper bound of the range of journal articles (not inclusive)
754            * @return the range of matching journal articles
755            */
756            public java.util.List<JournalArticle> findByDDMStructureKey(
757                    java.lang.String DDMStructureKey, int start, int end);
758    
759            /**
760            * Returns an ordered range of all the journal articles where DDMStructureKey = &#63;.
761            *
762            * <p>
763            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
764            * </p>
765            *
766            * @param DDMStructureKey the d d m structure key
767            * @param start the lower bound of the range of journal articles
768            * @param end the upper bound of the range of journal articles (not inclusive)
769            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
770            * @return the ordered range of matching journal articles
771            */
772            public java.util.List<JournalArticle> findByDDMStructureKey(
773                    java.lang.String DDMStructureKey, int start, int end,
774                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
775    
776            /**
777            * Returns the first journal article in the ordered set where DDMStructureKey = &#63;.
778            *
779            * @param DDMStructureKey the d d m structure key
780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
781            * @return the first matching journal article
782            * @throws NoSuchArticleException if a matching journal article could not be found
783            */
784            public JournalArticle findByDDMStructureKey_First(
785                    java.lang.String DDMStructureKey,
786                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
787                    throws com.liferay.portlet.journal.NoSuchArticleException;
788    
789            /**
790            * Returns the first journal article in the ordered set where DDMStructureKey = &#63;.
791            *
792            * @param DDMStructureKey the d d m structure key
793            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
794            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
795            */
796            public JournalArticle fetchByDDMStructureKey_First(
797                    java.lang.String DDMStructureKey,
798                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
799    
800            /**
801            * Returns the last journal article in the ordered set where DDMStructureKey = &#63;.
802            *
803            * @param DDMStructureKey the d d m structure key
804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
805            * @return the last matching journal article
806            * @throws NoSuchArticleException if a matching journal article could not be found
807            */
808            public JournalArticle findByDDMStructureKey_Last(
809                    java.lang.String DDMStructureKey,
810                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
811                    throws com.liferay.portlet.journal.NoSuchArticleException;
812    
813            /**
814            * Returns the last journal article in the ordered set where DDMStructureKey = &#63;.
815            *
816            * @param DDMStructureKey the d d m structure key
817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
818            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
819            */
820            public JournalArticle fetchByDDMStructureKey_Last(
821                    java.lang.String DDMStructureKey,
822                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
823    
824            /**
825            * Returns the journal articles before and after the current journal article in the ordered set where DDMStructureKey = &#63;.
826            *
827            * @param id the primary key of the current journal article
828            * @param DDMStructureKey the d d m structure key
829            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
830            * @return the previous, current, and next journal article
831            * @throws NoSuchArticleException if a journal article with the primary key could not be found
832            */
833            public JournalArticle[] findByDDMStructureKey_PrevAndNext(long id,
834                    java.lang.String DDMStructureKey,
835                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
836                    throws com.liferay.portlet.journal.NoSuchArticleException;
837    
838            /**
839            * Returns all the journal articles where DDMStructureKey = any &#63;.
840            *
841            * <p>
842            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
843            * </p>
844            *
845            * @param DDMStructureKeies the d d m structure keies
846            * @return the matching journal articles
847            */
848            public java.util.List<JournalArticle> findByDDMStructureKey(
849                    java.lang.String[] DDMStructureKeies);
850    
851            /**
852            * Returns a range of all the journal articles where DDMStructureKey = any &#63;.
853            *
854            * <p>
855            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
856            * </p>
857            *
858            * @param DDMStructureKeies the d d m structure keies
859            * @param start the lower bound of the range of journal articles
860            * @param end the upper bound of the range of journal articles (not inclusive)
861            * @return the range of matching journal articles
862            */
863            public java.util.List<JournalArticle> findByDDMStructureKey(
864                    java.lang.String[] DDMStructureKeies, int start, int end);
865    
866            /**
867            * Returns an ordered range of all the journal articles where DDMStructureKey = any &#63;.
868            *
869            * <p>
870            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
871            * </p>
872            *
873            * @param DDMStructureKeies the d d m structure keies
874            * @param start the lower bound of the range of journal articles
875            * @param end the upper bound of the range of journal articles (not inclusive)
876            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
877            * @return the ordered range of matching journal articles
878            */
879            public java.util.List<JournalArticle> findByDDMStructureKey(
880                    java.lang.String[] DDMStructureKeies, int start, int end,
881                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
882    
883            /**
884            * Removes all the journal articles where DDMStructureKey = &#63; from the database.
885            *
886            * @param DDMStructureKey the d d m structure key
887            */
888            public void removeByDDMStructureKey(java.lang.String DDMStructureKey);
889    
890            /**
891            * Returns the number of journal articles where DDMStructureKey = &#63;.
892            *
893            * @param DDMStructureKey the d d m structure key
894            * @return the number of matching journal articles
895            */
896            public int countByDDMStructureKey(java.lang.String DDMStructureKey);
897    
898            /**
899            * Returns the number of journal articles where DDMStructureKey = any &#63;.
900            *
901            * @param DDMStructureKeies the d d m structure keies
902            * @return the number of matching journal articles
903            */
904            public int countByDDMStructureKey(java.lang.String[] DDMStructureKeies);
905    
906            /**
907            * Returns all the journal articles where DDMTemplateKey = &#63;.
908            *
909            * @param DDMTemplateKey the d d m template key
910            * @return the matching journal articles
911            */
912            public java.util.List<JournalArticle> findByDDMTemplateKey(
913                    java.lang.String DDMTemplateKey);
914    
915            /**
916            * Returns a range of all the journal articles where DDMTemplateKey = &#63;.
917            *
918            * <p>
919            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
920            * </p>
921            *
922            * @param DDMTemplateKey the d d m template key
923            * @param start the lower bound of the range of journal articles
924            * @param end the upper bound of the range of journal articles (not inclusive)
925            * @return the range of matching journal articles
926            */
927            public java.util.List<JournalArticle> findByDDMTemplateKey(
928                    java.lang.String DDMTemplateKey, int start, int end);
929    
930            /**
931            * Returns an ordered range of all the journal articles where DDMTemplateKey = &#63;.
932            *
933            * <p>
934            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
935            * </p>
936            *
937            * @param DDMTemplateKey the d d m template key
938            * @param start the lower bound of the range of journal articles
939            * @param end the upper bound of the range of journal articles (not inclusive)
940            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
941            * @return the ordered range of matching journal articles
942            */
943            public java.util.List<JournalArticle> findByDDMTemplateKey(
944                    java.lang.String DDMTemplateKey, int start, int end,
945                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
946    
947            /**
948            * Returns the first journal article in the ordered set where DDMTemplateKey = &#63;.
949            *
950            * @param DDMTemplateKey the d d m template key
951            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
952            * @return the first matching journal article
953            * @throws NoSuchArticleException if a matching journal article could not be found
954            */
955            public JournalArticle findByDDMTemplateKey_First(
956                    java.lang.String DDMTemplateKey,
957                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
958                    throws com.liferay.portlet.journal.NoSuchArticleException;
959    
960            /**
961            * Returns the first journal article in the ordered set where DDMTemplateKey = &#63;.
962            *
963            * @param DDMTemplateKey the d d m template key
964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
965            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
966            */
967            public JournalArticle fetchByDDMTemplateKey_First(
968                    java.lang.String DDMTemplateKey,
969                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
970    
971            /**
972            * Returns the last journal article in the ordered set where DDMTemplateKey = &#63;.
973            *
974            * @param DDMTemplateKey the d d m template key
975            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
976            * @return the last matching journal article
977            * @throws NoSuchArticleException if a matching journal article could not be found
978            */
979            public JournalArticle findByDDMTemplateKey_Last(
980                    java.lang.String DDMTemplateKey,
981                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
982                    throws com.liferay.portlet.journal.NoSuchArticleException;
983    
984            /**
985            * Returns the last journal article in the ordered set where DDMTemplateKey = &#63;.
986            *
987            * @param DDMTemplateKey the d d m template key
988            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
989            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
990            */
991            public JournalArticle fetchByDDMTemplateKey_Last(
992                    java.lang.String DDMTemplateKey,
993                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
994    
995            /**
996            * Returns the journal articles before and after the current journal article in the ordered set where DDMTemplateKey = &#63;.
997            *
998            * @param id the primary key of the current journal article
999            * @param DDMTemplateKey the d d m template key
1000            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1001            * @return the previous, current, and next journal article
1002            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1003            */
1004            public JournalArticle[] findByDDMTemplateKey_PrevAndNext(long id,
1005                    java.lang.String DDMTemplateKey,
1006                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1007                    throws com.liferay.portlet.journal.NoSuchArticleException;
1008    
1009            /**
1010            * Removes all the journal articles where DDMTemplateKey = &#63; from the database.
1011            *
1012            * @param DDMTemplateKey the d d m template key
1013            */
1014            public void removeByDDMTemplateKey(java.lang.String DDMTemplateKey);
1015    
1016            /**
1017            * Returns the number of journal articles where DDMTemplateKey = &#63;.
1018            *
1019            * @param DDMTemplateKey the d d m template key
1020            * @return the number of matching journal articles
1021            */
1022            public int countByDDMTemplateKey(java.lang.String DDMTemplateKey);
1023    
1024            /**
1025            * Returns all the journal articles where layoutUuid = &#63;.
1026            *
1027            * @param layoutUuid the layout uuid
1028            * @return the matching journal articles
1029            */
1030            public java.util.List<JournalArticle> findByLayoutUuid(
1031                    java.lang.String layoutUuid);
1032    
1033            /**
1034            * Returns a range of all the journal articles where layoutUuid = &#63;.
1035            *
1036            * <p>
1037            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1038            * </p>
1039            *
1040            * @param layoutUuid the layout uuid
1041            * @param start the lower bound of the range of journal articles
1042            * @param end the upper bound of the range of journal articles (not inclusive)
1043            * @return the range of matching journal articles
1044            */
1045            public java.util.List<JournalArticle> findByLayoutUuid(
1046                    java.lang.String layoutUuid, int start, int end);
1047    
1048            /**
1049            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1050            *
1051            * <p>
1052            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1053            * </p>
1054            *
1055            * @param layoutUuid the layout uuid
1056            * @param start the lower bound of the range of journal articles
1057            * @param end the upper bound of the range of journal articles (not inclusive)
1058            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1059            * @return the ordered range of matching journal articles
1060            */
1061            public java.util.List<JournalArticle> findByLayoutUuid(
1062                    java.lang.String layoutUuid, int start, int end,
1063                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1064    
1065            /**
1066            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1067            *
1068            * @param layoutUuid the layout uuid
1069            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1070            * @return the first matching journal article
1071            * @throws NoSuchArticleException if a matching journal article could not be found
1072            */
1073            public JournalArticle findByLayoutUuid_First(java.lang.String layoutUuid,
1074                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1075                    throws com.liferay.portlet.journal.NoSuchArticleException;
1076    
1077            /**
1078            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1079            *
1080            * @param layoutUuid the layout uuid
1081            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1082            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1083            */
1084            public JournalArticle fetchByLayoutUuid_First(java.lang.String layoutUuid,
1085                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1086    
1087            /**
1088            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1089            *
1090            * @param layoutUuid the layout uuid
1091            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1092            * @return the last matching journal article
1093            * @throws NoSuchArticleException if a matching journal article could not be found
1094            */
1095            public JournalArticle findByLayoutUuid_Last(java.lang.String layoutUuid,
1096                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1097                    throws com.liferay.portlet.journal.NoSuchArticleException;
1098    
1099            /**
1100            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1101            *
1102            * @param layoutUuid the layout uuid
1103            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1104            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1105            */
1106            public JournalArticle fetchByLayoutUuid_Last(java.lang.String layoutUuid,
1107                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1108    
1109            /**
1110            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1111            *
1112            * @param id the primary key of the current journal article
1113            * @param layoutUuid the layout uuid
1114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1115            * @return the previous, current, and next journal article
1116            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1117            */
1118            public JournalArticle[] findByLayoutUuid_PrevAndNext(long id,
1119                    java.lang.String layoutUuid,
1120                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1121                    throws com.liferay.portlet.journal.NoSuchArticleException;
1122    
1123            /**
1124            * Removes all the journal articles where layoutUuid = &#63; from the database.
1125            *
1126            * @param layoutUuid the layout uuid
1127            */
1128            public void removeByLayoutUuid(java.lang.String layoutUuid);
1129    
1130            /**
1131            * Returns the number of journal articles where layoutUuid = &#63;.
1132            *
1133            * @param layoutUuid the layout uuid
1134            * @return the number of matching journal articles
1135            */
1136            public int countByLayoutUuid(java.lang.String layoutUuid);
1137    
1138            /**
1139            * Returns all the journal articles where smallImageId = &#63;.
1140            *
1141            * @param smallImageId the small image ID
1142            * @return the matching journal articles
1143            */
1144            public java.util.List<JournalArticle> findBySmallImageId(long smallImageId);
1145    
1146            /**
1147            * Returns a range of all the journal articles where smallImageId = &#63;.
1148            *
1149            * <p>
1150            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1151            * </p>
1152            *
1153            * @param smallImageId the small image ID
1154            * @param start the lower bound of the range of journal articles
1155            * @param end the upper bound of the range of journal articles (not inclusive)
1156            * @return the range of matching journal articles
1157            */
1158            public java.util.List<JournalArticle> findBySmallImageId(
1159                    long smallImageId, int start, int end);
1160    
1161            /**
1162            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1163            *
1164            * <p>
1165            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1166            * </p>
1167            *
1168            * @param smallImageId the small image ID
1169            * @param start the lower bound of the range of journal articles
1170            * @param end the upper bound of the range of journal articles (not inclusive)
1171            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1172            * @return the ordered range of matching journal articles
1173            */
1174            public java.util.List<JournalArticle> findBySmallImageId(
1175                    long smallImageId, int start, int end,
1176                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1177    
1178            /**
1179            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1180            *
1181            * @param smallImageId the small image ID
1182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1183            * @return the first matching journal article
1184            * @throws NoSuchArticleException if a matching journal article could not be found
1185            */
1186            public JournalArticle findBySmallImageId_First(long smallImageId,
1187                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1188                    throws com.liferay.portlet.journal.NoSuchArticleException;
1189    
1190            /**
1191            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1192            *
1193            * @param smallImageId the small image ID
1194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1195            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1196            */
1197            public JournalArticle fetchBySmallImageId_First(long smallImageId,
1198                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1199    
1200            /**
1201            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1202            *
1203            * @param smallImageId the small image ID
1204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1205            * @return the last matching journal article
1206            * @throws NoSuchArticleException if a matching journal article could not be found
1207            */
1208            public JournalArticle findBySmallImageId_Last(long smallImageId,
1209                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1210                    throws com.liferay.portlet.journal.NoSuchArticleException;
1211    
1212            /**
1213            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1214            *
1215            * @param smallImageId the small image ID
1216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1217            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1218            */
1219            public JournalArticle fetchBySmallImageId_Last(long smallImageId,
1220                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1221    
1222            /**
1223            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1224            *
1225            * @param id the primary key of the current journal article
1226            * @param smallImageId the small image ID
1227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1228            * @return the previous, current, and next journal article
1229            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1230            */
1231            public JournalArticle[] findBySmallImageId_PrevAndNext(long id,
1232                    long smallImageId,
1233                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1234                    throws com.liferay.portlet.journal.NoSuchArticleException;
1235    
1236            /**
1237            * Removes all the journal articles where smallImageId = &#63; from the database.
1238            *
1239            * @param smallImageId the small image ID
1240            */
1241            public void removeBySmallImageId(long smallImageId);
1242    
1243            /**
1244            * Returns the number of journal articles where smallImageId = &#63;.
1245            *
1246            * @param smallImageId the small image ID
1247            * @return the number of matching journal articles
1248            */
1249            public int countBySmallImageId(long smallImageId);
1250    
1251            /**
1252            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1253            *
1254            * @param resourcePrimKey the resource prim key
1255            * @param indexable the indexable
1256            * @return the matching journal articles
1257            */
1258            public java.util.List<JournalArticle> findByR_I(long resourcePrimKey,
1259                    boolean indexable);
1260    
1261            /**
1262            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1263            *
1264            * <p>
1265            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1266            * </p>
1267            *
1268            * @param resourcePrimKey the resource prim key
1269            * @param indexable the indexable
1270            * @param start the lower bound of the range of journal articles
1271            * @param end the upper bound of the range of journal articles (not inclusive)
1272            * @return the range of matching journal articles
1273            */
1274            public java.util.List<JournalArticle> findByR_I(long resourcePrimKey,
1275                    boolean indexable, int start, int end);
1276    
1277            /**
1278            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1279            *
1280            * <p>
1281            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1282            * </p>
1283            *
1284            * @param resourcePrimKey the resource prim key
1285            * @param indexable the indexable
1286            * @param start the lower bound of the range of journal articles
1287            * @param end the upper bound of the range of journal articles (not inclusive)
1288            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1289            * @return the ordered range of matching journal articles
1290            */
1291            public java.util.List<JournalArticle> findByR_I(long resourcePrimKey,
1292                    boolean indexable, int start, int end,
1293                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1294    
1295            /**
1296            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1297            *
1298            * @param resourcePrimKey the resource prim key
1299            * @param indexable the indexable
1300            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1301            * @return the first matching journal article
1302            * @throws NoSuchArticleException if a matching journal article could not be found
1303            */
1304            public JournalArticle findByR_I_First(long resourcePrimKey,
1305                    boolean indexable,
1306                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1307                    throws com.liferay.portlet.journal.NoSuchArticleException;
1308    
1309            /**
1310            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1311            *
1312            * @param resourcePrimKey the resource prim key
1313            * @param indexable the indexable
1314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1315            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1316            */
1317            public JournalArticle fetchByR_I_First(long resourcePrimKey,
1318                    boolean indexable,
1319                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1320    
1321            /**
1322            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1323            *
1324            * @param resourcePrimKey the resource prim key
1325            * @param indexable the indexable
1326            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1327            * @return the last matching journal article
1328            * @throws NoSuchArticleException if a matching journal article could not be found
1329            */
1330            public JournalArticle findByR_I_Last(long resourcePrimKey,
1331                    boolean indexable,
1332                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1333                    throws com.liferay.portlet.journal.NoSuchArticleException;
1334    
1335            /**
1336            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1337            *
1338            * @param resourcePrimKey the resource prim key
1339            * @param indexable the indexable
1340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1341            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1342            */
1343            public JournalArticle fetchByR_I_Last(long resourcePrimKey,
1344                    boolean indexable,
1345                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1346    
1347            /**
1348            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1349            *
1350            * @param id the primary key of the current journal article
1351            * @param resourcePrimKey the resource prim key
1352            * @param indexable the indexable
1353            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1354            * @return the previous, current, and next journal article
1355            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1356            */
1357            public JournalArticle[] findByR_I_PrevAndNext(long id,
1358                    long resourcePrimKey, boolean indexable,
1359                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1360                    throws com.liferay.portlet.journal.NoSuchArticleException;
1361    
1362            /**
1363            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; from the database.
1364            *
1365            * @param resourcePrimKey the resource prim key
1366            * @param indexable the indexable
1367            */
1368            public void removeByR_I(long resourcePrimKey, boolean indexable);
1369    
1370            /**
1371            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1372            *
1373            * @param resourcePrimKey the resource prim key
1374            * @param indexable the indexable
1375            * @return the number of matching journal articles
1376            */
1377            public int countByR_I(long resourcePrimKey, boolean indexable);
1378    
1379            /**
1380            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1381            *
1382            * @param resourcePrimKey the resource prim key
1383            * @param status the status
1384            * @return the matching journal articles
1385            */
1386            public java.util.List<JournalArticle> findByR_ST(long resourcePrimKey,
1387                    int status);
1388    
1389            /**
1390            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1391            *
1392            * <p>
1393            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1394            * </p>
1395            *
1396            * @param resourcePrimKey the resource prim key
1397            * @param status the status
1398            * @param start the lower bound of the range of journal articles
1399            * @param end the upper bound of the range of journal articles (not inclusive)
1400            * @return the range of matching journal articles
1401            */
1402            public java.util.List<JournalArticle> findByR_ST(long resourcePrimKey,
1403                    int status, int start, int end);
1404    
1405            /**
1406            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1407            *
1408            * <p>
1409            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1410            * </p>
1411            *
1412            * @param resourcePrimKey the resource prim key
1413            * @param status the status
1414            * @param start the lower bound of the range of journal articles
1415            * @param end the upper bound of the range of journal articles (not inclusive)
1416            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1417            * @return the ordered range of matching journal articles
1418            */
1419            public java.util.List<JournalArticle> findByR_ST(long resourcePrimKey,
1420                    int status, int start, int end,
1421                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1422    
1423            /**
1424            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1425            *
1426            * @param resourcePrimKey the resource prim key
1427            * @param status the status
1428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1429            * @return the first matching journal article
1430            * @throws NoSuchArticleException if a matching journal article could not be found
1431            */
1432            public JournalArticle findByR_ST_First(long resourcePrimKey, int status,
1433                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1434                    throws com.liferay.portlet.journal.NoSuchArticleException;
1435    
1436            /**
1437            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1438            *
1439            * @param resourcePrimKey the resource prim key
1440            * @param status the status
1441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1442            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1443            */
1444            public JournalArticle fetchByR_ST_First(long resourcePrimKey, int status,
1445                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1446    
1447            /**
1448            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1449            *
1450            * @param resourcePrimKey the resource prim key
1451            * @param status the status
1452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1453            * @return the last matching journal article
1454            * @throws NoSuchArticleException if a matching journal article could not be found
1455            */
1456            public JournalArticle findByR_ST_Last(long resourcePrimKey, int status,
1457                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1458                    throws com.liferay.portlet.journal.NoSuchArticleException;
1459    
1460            /**
1461            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1462            *
1463            * @param resourcePrimKey the resource prim key
1464            * @param status the status
1465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1466            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1467            */
1468            public JournalArticle fetchByR_ST_Last(long resourcePrimKey, int status,
1469                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1470    
1471            /**
1472            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1473            *
1474            * @param id the primary key of the current journal article
1475            * @param resourcePrimKey the resource prim key
1476            * @param status the status
1477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1478            * @return the previous, current, and next journal article
1479            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1480            */
1481            public JournalArticle[] findByR_ST_PrevAndNext(long id,
1482                    long resourcePrimKey, int status,
1483                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1484                    throws com.liferay.portlet.journal.NoSuchArticleException;
1485    
1486            /**
1487            * Returns all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1488            *
1489            * <p>
1490            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1491            * </p>
1492            *
1493            * @param resourcePrimKey the resource prim key
1494            * @param statuses the statuses
1495            * @return the matching journal articles
1496            */
1497            public java.util.List<JournalArticle> findByR_ST(long resourcePrimKey,
1498                    int[] statuses);
1499    
1500            /**
1501            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1502            *
1503            * <p>
1504            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1505            * </p>
1506            *
1507            * @param resourcePrimKey the resource prim key
1508            * @param statuses the statuses
1509            * @param start the lower bound of the range of journal articles
1510            * @param end the upper bound of the range of journal articles (not inclusive)
1511            * @return the range of matching journal articles
1512            */
1513            public java.util.List<JournalArticle> findByR_ST(long resourcePrimKey,
1514                    int[] statuses, int start, int end);
1515    
1516            /**
1517            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1518            *
1519            * <p>
1520            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1521            * </p>
1522            *
1523            * @param resourcePrimKey the resource prim key
1524            * @param statuses the statuses
1525            * @param start the lower bound of the range of journal articles
1526            * @param end the upper bound of the range of journal articles (not inclusive)
1527            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1528            * @return the ordered range of matching journal articles
1529            */
1530            public java.util.List<JournalArticle> findByR_ST(long resourcePrimKey,
1531                    int[] statuses, int start, int end,
1532                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1533    
1534            /**
1535            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
1536            *
1537            * @param resourcePrimKey the resource prim key
1538            * @param status the status
1539            */
1540            public void removeByR_ST(long resourcePrimKey, int status);
1541    
1542            /**
1543            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
1544            *
1545            * @param resourcePrimKey the resource prim key
1546            * @param status the status
1547            * @return the number of matching journal articles
1548            */
1549            public int countByR_ST(long resourcePrimKey, int status);
1550    
1551            /**
1552            * Returns the number of journal articles where resourcePrimKey = &#63; and status = any &#63;.
1553            *
1554            * @param resourcePrimKey the resource prim key
1555            * @param statuses the statuses
1556            * @return the number of matching journal articles
1557            */
1558            public int countByR_ST(long resourcePrimKey, int[] statuses);
1559    
1560            /**
1561            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
1562            *
1563            * @param groupId the group ID
1564            * @param userId the user ID
1565            * @return the matching journal articles
1566            */
1567            public java.util.List<JournalArticle> findByG_U(long groupId, long userId);
1568    
1569            /**
1570            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
1571            *
1572            * <p>
1573            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1574            * </p>
1575            *
1576            * @param groupId the group ID
1577            * @param userId the user ID
1578            * @param start the lower bound of the range of journal articles
1579            * @param end the upper bound of the range of journal articles (not inclusive)
1580            * @return the range of matching journal articles
1581            */
1582            public java.util.List<JournalArticle> findByG_U(long groupId, long userId,
1583                    int start, int end);
1584    
1585            /**
1586            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
1587            *
1588            * <p>
1589            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1590            * </p>
1591            *
1592            * @param groupId the group ID
1593            * @param userId the user ID
1594            * @param start the lower bound of the range of journal articles
1595            * @param end the upper bound of the range of journal articles (not inclusive)
1596            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1597            * @return the ordered range of matching journal articles
1598            */
1599            public java.util.List<JournalArticle> findByG_U(long groupId, long userId,
1600                    int start, int end,
1601                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1602    
1603            /**
1604            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
1605            *
1606            * @param groupId the group ID
1607            * @param userId the user ID
1608            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1609            * @return the first matching journal article
1610            * @throws NoSuchArticleException if a matching journal article could not be found
1611            */
1612            public JournalArticle findByG_U_First(long groupId, long userId,
1613                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1614                    throws com.liferay.portlet.journal.NoSuchArticleException;
1615    
1616            /**
1617            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
1618            *
1619            * @param groupId the group ID
1620            * @param userId the user ID
1621            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1622            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1623            */
1624            public JournalArticle fetchByG_U_First(long groupId, long userId,
1625                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1626    
1627            /**
1628            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
1629            *
1630            * @param groupId the group ID
1631            * @param userId the user ID
1632            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1633            * @return the last matching journal article
1634            * @throws NoSuchArticleException if a matching journal article could not be found
1635            */
1636            public JournalArticle findByG_U_Last(long groupId, long userId,
1637                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1638                    throws com.liferay.portlet.journal.NoSuchArticleException;
1639    
1640            /**
1641            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
1642            *
1643            * @param groupId the group ID
1644            * @param userId the user ID
1645            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1646            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1647            */
1648            public JournalArticle fetchByG_U_Last(long groupId, long userId,
1649                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1650    
1651            /**
1652            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
1653            *
1654            * @param id the primary key of the current journal article
1655            * @param groupId the group ID
1656            * @param userId the user ID
1657            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1658            * @return the previous, current, and next journal article
1659            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1660            */
1661            public JournalArticle[] findByG_U_PrevAndNext(long id, long groupId,
1662                    long userId,
1663                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1664                    throws com.liferay.portlet.journal.NoSuchArticleException;
1665    
1666            /**
1667            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
1668            *
1669            * @param groupId the group ID
1670            * @param userId the user ID
1671            * @return the matching journal articles that the user has permission to view
1672            */
1673            public java.util.List<JournalArticle> filterFindByG_U(long groupId,
1674                    long userId);
1675    
1676            /**
1677            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
1678            *
1679            * <p>
1680            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1681            * </p>
1682            *
1683            * @param groupId the group ID
1684            * @param userId the user ID
1685            * @param start the lower bound of the range of journal articles
1686            * @param end the upper bound of the range of journal articles (not inclusive)
1687            * @return the range of matching journal articles that the user has permission to view
1688            */
1689            public java.util.List<JournalArticle> filterFindByG_U(long groupId,
1690                    long userId, int start, int end);
1691    
1692            /**
1693            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
1694            *
1695            * <p>
1696            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1697            * </p>
1698            *
1699            * @param groupId the group ID
1700            * @param userId the user ID
1701            * @param start the lower bound of the range of journal articles
1702            * @param end the upper bound of the range of journal articles (not inclusive)
1703            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1704            * @return the ordered range of matching journal articles that the user has permission to view
1705            */
1706            public java.util.List<JournalArticle> filterFindByG_U(long groupId,
1707                    long userId, int start, int end,
1708                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1709    
1710            /**
1711            * 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;.
1712            *
1713            * @param id the primary key of the current journal article
1714            * @param groupId the group ID
1715            * @param userId the user ID
1716            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1717            * @return the previous, current, and next journal article
1718            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1719            */
1720            public JournalArticle[] filterFindByG_U_PrevAndNext(long id, long groupId,
1721                    long userId,
1722                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1723                    throws com.liferay.portlet.journal.NoSuchArticleException;
1724    
1725            /**
1726            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
1727            *
1728            * @param groupId the group ID
1729            * @param userId the user ID
1730            */
1731            public void removeByG_U(long groupId, long userId);
1732    
1733            /**
1734            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
1735            *
1736            * @param groupId the group ID
1737            * @param userId the user ID
1738            * @return the number of matching journal articles
1739            */
1740            public int countByG_U(long groupId, long userId);
1741    
1742            /**
1743            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
1744            *
1745            * @param groupId the group ID
1746            * @param userId the user ID
1747            * @return the number of matching journal articles that the user has permission to view
1748            */
1749            public int filterCountByG_U(long groupId, long userId);
1750    
1751            /**
1752            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
1753            *
1754            * @param groupId the group ID
1755            * @param folderId the folder ID
1756            * @return the matching journal articles
1757            */
1758            public java.util.List<JournalArticle> findByG_F(long groupId, long folderId);
1759    
1760            /**
1761            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
1762            *
1763            * <p>
1764            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1765            * </p>
1766            *
1767            * @param groupId the group ID
1768            * @param folderId the folder ID
1769            * @param start the lower bound of the range of journal articles
1770            * @param end the upper bound of the range of journal articles (not inclusive)
1771            * @return the range of matching journal articles
1772            */
1773            public java.util.List<JournalArticle> findByG_F(long groupId,
1774                    long folderId, int start, int end);
1775    
1776            /**
1777            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
1778            *
1779            * <p>
1780            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1781            * </p>
1782            *
1783            * @param groupId the group ID
1784            * @param folderId the folder ID
1785            * @param start the lower bound of the range of journal articles
1786            * @param end the upper bound of the range of journal articles (not inclusive)
1787            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1788            * @return the ordered range of matching journal articles
1789            */
1790            public java.util.List<JournalArticle> findByG_F(long groupId,
1791                    long folderId, int start, int end,
1792                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1793    
1794            /**
1795            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
1796            *
1797            * @param groupId the group ID
1798            * @param folderId the folder ID
1799            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1800            * @return the first matching journal article
1801            * @throws NoSuchArticleException if a matching journal article could not be found
1802            */
1803            public JournalArticle findByG_F_First(long groupId, long folderId,
1804                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1805                    throws com.liferay.portlet.journal.NoSuchArticleException;
1806    
1807            /**
1808            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
1809            *
1810            * @param groupId the group ID
1811            * @param folderId the folder ID
1812            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1813            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1814            */
1815            public JournalArticle fetchByG_F_First(long groupId, long folderId,
1816                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1817    
1818            /**
1819            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
1820            *
1821            * @param groupId the group ID
1822            * @param folderId the folder ID
1823            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1824            * @return the last matching journal article
1825            * @throws NoSuchArticleException if a matching journal article could not be found
1826            */
1827            public JournalArticle findByG_F_Last(long groupId, long folderId,
1828                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1829                    throws com.liferay.portlet.journal.NoSuchArticleException;
1830    
1831            /**
1832            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
1833            *
1834            * @param groupId the group ID
1835            * @param folderId the folder ID
1836            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1837            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1838            */
1839            public JournalArticle fetchByG_F_Last(long groupId, long folderId,
1840                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1841    
1842            /**
1843            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
1844            *
1845            * @param id the primary key of the current journal article
1846            * @param groupId the group ID
1847            * @param folderId the folder ID
1848            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1849            * @return the previous, current, and next journal article
1850            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1851            */
1852            public JournalArticle[] findByG_F_PrevAndNext(long id, long groupId,
1853                    long folderId,
1854                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1855                    throws com.liferay.portlet.journal.NoSuchArticleException;
1856    
1857            /**
1858            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
1859            *
1860            * @param groupId the group ID
1861            * @param folderId the folder ID
1862            * @return the matching journal articles that the user has permission to view
1863            */
1864            public java.util.List<JournalArticle> filterFindByG_F(long groupId,
1865                    long folderId);
1866    
1867            /**
1868            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID
1875            * @param folderId the folder ID
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            * @return the range of matching journal articles that the user has permission to view
1879            */
1880            public java.util.List<JournalArticle> filterFindByG_F(long groupId,
1881                    long folderId, int start, int end);
1882    
1883            /**
1884            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
1885            *
1886            * <p>
1887            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1888            * </p>
1889            *
1890            * @param groupId the group ID
1891            * @param folderId the folder ID
1892            * @param start the lower bound of the range of journal articles
1893            * @param end the upper bound of the range of journal articles (not inclusive)
1894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1895            * @return the ordered range of matching journal articles that the user has permission to view
1896            */
1897            public java.util.List<JournalArticle> filterFindByG_F(long groupId,
1898                    long folderId, int start, int end,
1899                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1900    
1901            /**
1902            * 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;.
1903            *
1904            * @param id the primary key of the current journal article
1905            * @param groupId the group ID
1906            * @param folderId the folder ID
1907            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1908            * @return the previous, current, and next journal article
1909            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1910            */
1911            public JournalArticle[] filterFindByG_F_PrevAndNext(long id, long groupId,
1912                    long folderId,
1913                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
1914                    throws com.liferay.portlet.journal.NoSuchArticleException;
1915    
1916            /**
1917            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1918            *
1919            * @param groupId the group ID
1920            * @param folderIds the folder IDs
1921            * @return the matching journal articles that the user has permission to view
1922            */
1923            public java.util.List<JournalArticle> filterFindByG_F(long groupId,
1924                    long[] folderIds);
1925    
1926            /**
1927            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1928            *
1929            * <p>
1930            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1931            * </p>
1932            *
1933            * @param groupId the group ID
1934            * @param folderIds the folder IDs
1935            * @param start the lower bound of the range of journal articles
1936            * @param end the upper bound of the range of journal articles (not inclusive)
1937            * @return the range of matching journal articles that the user has permission to view
1938            */
1939            public java.util.List<JournalArticle> filterFindByG_F(long groupId,
1940                    long[] folderIds, int start, int end);
1941    
1942            /**
1943            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1944            *
1945            * <p>
1946            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1947            * </p>
1948            *
1949            * @param groupId the group ID
1950            * @param folderIds the folder IDs
1951            * @param start the lower bound of the range of journal articles
1952            * @param end the upper bound of the range of journal articles (not inclusive)
1953            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1954            * @return the ordered range of matching journal articles that the user has permission to view
1955            */
1956            public java.util.List<JournalArticle> filterFindByG_F(long groupId,
1957                    long[] folderIds, int start, int end,
1958                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
1959    
1960            /**
1961            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
1962            *
1963            * <p>
1964            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1965            * </p>
1966            *
1967            * @param groupId the group ID
1968            * @param folderIds the folder IDs
1969            * @return the matching journal articles
1970            */
1971            public java.util.List<JournalArticle> findByG_F(long groupId,
1972                    long[] folderIds);
1973    
1974            /**
1975            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
1976            *
1977            * <p>
1978            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1979            * </p>
1980            *
1981            * @param groupId the group ID
1982            * @param folderIds the folder IDs
1983            * @param start the lower bound of the range of journal articles
1984            * @param end the upper bound of the range of journal articles (not inclusive)
1985            * @return the range of matching journal articles
1986            */
1987            public java.util.List<JournalArticle> findByG_F(long groupId,
1988                    long[] folderIds, int start, int end);
1989    
1990            /**
1991            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
1992            *
1993            * <p>
1994            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1995            * </p>
1996            *
1997            * @param groupId the group ID
1998            * @param folderIds the folder IDs
1999            * @param start the lower bound of the range of journal articles
2000            * @param end the upper bound of the range of journal articles (not inclusive)
2001            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2002            * @return the ordered range of matching journal articles
2003            */
2004            public java.util.List<JournalArticle> findByG_F(long groupId,
2005                    long[] folderIds, int start, int end,
2006                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2007    
2008            /**
2009            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2010            *
2011            * @param groupId the group ID
2012            * @param folderId the folder ID
2013            */
2014            public void removeByG_F(long groupId, long folderId);
2015    
2016            /**
2017            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2018            *
2019            * @param groupId the group ID
2020            * @param folderId the folder ID
2021            * @return the number of matching journal articles
2022            */
2023            public int countByG_F(long groupId, long folderId);
2024    
2025            /**
2026            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2027            *
2028            * @param groupId the group ID
2029            * @param folderIds the folder IDs
2030            * @return the number of matching journal articles
2031            */
2032            public int countByG_F(long groupId, long[] folderIds);
2033    
2034            /**
2035            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2036            *
2037            * @param groupId the group ID
2038            * @param folderId the folder ID
2039            * @return the number of matching journal articles that the user has permission to view
2040            */
2041            public int filterCountByG_F(long groupId, long folderId);
2042    
2043            /**
2044            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2045            *
2046            * @param groupId the group ID
2047            * @param folderIds the folder IDs
2048            * @return the number of matching journal articles that the user has permission to view
2049            */
2050            public int filterCountByG_F(long groupId, long[] folderIds);
2051    
2052            /**
2053            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2054            *
2055            * @param groupId the group ID
2056            * @param articleId the article ID
2057            * @return the matching journal articles
2058            */
2059            public java.util.List<JournalArticle> findByG_A(long groupId,
2060                    java.lang.String articleId);
2061    
2062            /**
2063            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2064            *
2065            * <p>
2066            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2067            * </p>
2068            *
2069            * @param groupId the group ID
2070            * @param articleId the article ID
2071            * @param start the lower bound of the range of journal articles
2072            * @param end the upper bound of the range of journal articles (not inclusive)
2073            * @return the range of matching journal articles
2074            */
2075            public java.util.List<JournalArticle> findByG_A(long groupId,
2076                    java.lang.String articleId, int start, int end);
2077    
2078            /**
2079            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2080            *
2081            * <p>
2082            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2083            * </p>
2084            *
2085            * @param groupId the group ID
2086            * @param articleId the article ID
2087            * @param start the lower bound of the range of journal articles
2088            * @param end the upper bound of the range of journal articles (not inclusive)
2089            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2090            * @return the ordered range of matching journal articles
2091            */
2092            public java.util.List<JournalArticle> findByG_A(long groupId,
2093                    java.lang.String articleId, int start, int end,
2094                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2095    
2096            /**
2097            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2098            *
2099            * @param groupId the group ID
2100            * @param articleId the article ID
2101            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2102            * @return the first matching journal article
2103            * @throws NoSuchArticleException if a matching journal article could not be found
2104            */
2105            public JournalArticle findByG_A_First(long groupId,
2106                    java.lang.String articleId,
2107                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2108                    throws com.liferay.portlet.journal.NoSuchArticleException;
2109    
2110            /**
2111            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2112            *
2113            * @param groupId the group ID
2114            * @param articleId the article ID
2115            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2116            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2117            */
2118            public JournalArticle fetchByG_A_First(long groupId,
2119                    java.lang.String articleId,
2120                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2121    
2122            /**
2123            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2124            *
2125            * @param groupId the group ID
2126            * @param articleId the article ID
2127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2128            * @return the last matching journal article
2129            * @throws NoSuchArticleException if a matching journal article could not be found
2130            */
2131            public JournalArticle findByG_A_Last(long groupId,
2132                    java.lang.String articleId,
2133                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2134                    throws com.liferay.portlet.journal.NoSuchArticleException;
2135    
2136            /**
2137            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2138            *
2139            * @param groupId the group ID
2140            * @param articleId the article ID
2141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2142            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2143            */
2144            public JournalArticle fetchByG_A_Last(long groupId,
2145                    java.lang.String articleId,
2146                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2147    
2148            /**
2149            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2150            *
2151            * @param id the primary key of the current journal article
2152            * @param groupId the group ID
2153            * @param articleId the article ID
2154            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2155            * @return the previous, current, and next journal article
2156            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2157            */
2158            public JournalArticle[] findByG_A_PrevAndNext(long id, long groupId,
2159                    java.lang.String articleId,
2160                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2161                    throws com.liferay.portlet.journal.NoSuchArticleException;
2162    
2163            /**
2164            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2165            *
2166            * @param groupId the group ID
2167            * @param articleId the article ID
2168            * @return the matching journal articles that the user has permission to view
2169            */
2170            public java.util.List<JournalArticle> filterFindByG_A(long groupId,
2171                    java.lang.String articleId);
2172    
2173            /**
2174            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2175            *
2176            * <p>
2177            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2178            * </p>
2179            *
2180            * @param groupId the group ID
2181            * @param articleId the article ID
2182            * @param start the lower bound of the range of journal articles
2183            * @param end the upper bound of the range of journal articles (not inclusive)
2184            * @return the range of matching journal articles that the user has permission to view
2185            */
2186            public java.util.List<JournalArticle> filterFindByG_A(long groupId,
2187                    java.lang.String articleId, int start, int end);
2188    
2189            /**
2190            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
2191            *
2192            * <p>
2193            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2194            * </p>
2195            *
2196            * @param groupId the group ID
2197            * @param articleId the article ID
2198            * @param start the lower bound of the range of journal articles
2199            * @param end the upper bound of the range of journal articles (not inclusive)
2200            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2201            * @return the ordered range of matching journal articles that the user has permission to view
2202            */
2203            public java.util.List<JournalArticle> filterFindByG_A(long groupId,
2204                    java.lang.String articleId, int start, int end,
2205                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2206    
2207            /**
2208            * 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;.
2209            *
2210            * @param id the primary key of the current journal article
2211            * @param groupId the group ID
2212            * @param articleId the article ID
2213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2214            * @return the previous, current, and next journal article
2215            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2216            */
2217            public JournalArticle[] filterFindByG_A_PrevAndNext(long id, long groupId,
2218                    java.lang.String articleId,
2219                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2220                    throws com.liferay.portlet.journal.NoSuchArticleException;
2221    
2222            /**
2223            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2224            *
2225            * @param groupId the group ID
2226            * @param articleId the article ID
2227            */
2228            public void removeByG_A(long groupId, java.lang.String articleId);
2229    
2230            /**
2231            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
2232            *
2233            * @param groupId the group ID
2234            * @param articleId the article ID
2235            * @return the number of matching journal articles
2236            */
2237            public int countByG_A(long groupId, java.lang.String articleId);
2238    
2239            /**
2240            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2241            *
2242            * @param groupId the group ID
2243            * @param articleId the article ID
2244            * @return the number of matching journal articles that the user has permission to view
2245            */
2246            public int filterCountByG_A(long groupId, java.lang.String articleId);
2247    
2248            /**
2249            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
2250            *
2251            * @param groupId the group ID
2252            * @param urlTitle the url title
2253            * @return the matching journal articles
2254            */
2255            public java.util.List<JournalArticle> findByG_UT(long groupId,
2256                    java.lang.String urlTitle);
2257    
2258            /**
2259            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2260            *
2261            * <p>
2262            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2263            * </p>
2264            *
2265            * @param groupId the group ID
2266            * @param urlTitle the url title
2267            * @param start the lower bound of the range of journal articles
2268            * @param end the upper bound of the range of journal articles (not inclusive)
2269            * @return the range of matching journal articles
2270            */
2271            public java.util.List<JournalArticle> findByG_UT(long groupId,
2272                    java.lang.String urlTitle, int start, int end);
2273    
2274            /**
2275            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2276            *
2277            * <p>
2278            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2279            * </p>
2280            *
2281            * @param groupId the group ID
2282            * @param urlTitle the url title
2283            * @param start the lower bound of the range of journal articles
2284            * @param end the upper bound of the range of journal articles (not inclusive)
2285            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2286            * @return the ordered range of matching journal articles
2287            */
2288            public java.util.List<JournalArticle> findByG_UT(long groupId,
2289                    java.lang.String urlTitle, int start, int end,
2290                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2291    
2292            /**
2293            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2294            *
2295            * @param groupId the group ID
2296            * @param urlTitle the url title
2297            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2298            * @return the first matching journal article
2299            * @throws NoSuchArticleException if a matching journal article could not be found
2300            */
2301            public JournalArticle findByG_UT_First(long groupId,
2302                    java.lang.String urlTitle,
2303                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2304                    throws com.liferay.portlet.journal.NoSuchArticleException;
2305    
2306            /**
2307            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2308            *
2309            * @param groupId the group ID
2310            * @param urlTitle the url title
2311            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2312            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2313            */
2314            public JournalArticle fetchByG_UT_First(long groupId,
2315                    java.lang.String urlTitle,
2316                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2317    
2318            /**
2319            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2320            *
2321            * @param groupId the group ID
2322            * @param urlTitle the url title
2323            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2324            * @return the last matching journal article
2325            * @throws NoSuchArticleException if a matching journal article could not be found
2326            */
2327            public JournalArticle findByG_UT_Last(long groupId,
2328                    java.lang.String urlTitle,
2329                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2330                    throws com.liferay.portlet.journal.NoSuchArticleException;
2331    
2332            /**
2333            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2334            *
2335            * @param groupId the group ID
2336            * @param urlTitle the url title
2337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2338            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2339            */
2340            public JournalArticle fetchByG_UT_Last(long groupId,
2341                    java.lang.String urlTitle,
2342                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2343    
2344            /**
2345            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2346            *
2347            * @param id the primary key of the current journal article
2348            * @param groupId the group ID
2349            * @param urlTitle the url title
2350            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2351            * @return the previous, current, and next journal article
2352            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2353            */
2354            public JournalArticle[] findByG_UT_PrevAndNext(long id, long groupId,
2355                    java.lang.String urlTitle,
2356                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2357                    throws com.liferay.portlet.journal.NoSuchArticleException;
2358    
2359            /**
2360            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2361            *
2362            * @param groupId the group ID
2363            * @param urlTitle the url title
2364            * @return the matching journal articles that the user has permission to view
2365            */
2366            public java.util.List<JournalArticle> filterFindByG_UT(long groupId,
2367                    java.lang.String urlTitle);
2368    
2369            /**
2370            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2371            *
2372            * <p>
2373            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2374            * </p>
2375            *
2376            * @param groupId the group ID
2377            * @param urlTitle the url title
2378            * @param start the lower bound of the range of journal articles
2379            * @param end the upper bound of the range of journal articles (not inclusive)
2380            * @return the range of matching journal articles that the user has permission to view
2381            */
2382            public java.util.List<JournalArticle> filterFindByG_UT(long groupId,
2383                    java.lang.String urlTitle, int start, int end);
2384    
2385            /**
2386            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
2387            *
2388            * <p>
2389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2390            * </p>
2391            *
2392            * @param groupId the group ID
2393            * @param urlTitle the url title
2394            * @param start the lower bound of the range of journal articles
2395            * @param end the upper bound of the range of journal articles (not inclusive)
2396            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2397            * @return the ordered range of matching journal articles that the user has permission to view
2398            */
2399            public java.util.List<JournalArticle> filterFindByG_UT(long groupId,
2400                    java.lang.String urlTitle, int start, int end,
2401                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2402    
2403            /**
2404            * 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;.
2405            *
2406            * @param id the primary key of the current journal article
2407            * @param groupId the group ID
2408            * @param urlTitle the url title
2409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2410            * @return the previous, current, and next journal article
2411            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2412            */
2413            public JournalArticle[] filterFindByG_UT_PrevAndNext(long id, long groupId,
2414                    java.lang.String urlTitle,
2415                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2416                    throws com.liferay.portlet.journal.NoSuchArticleException;
2417    
2418            /**
2419            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
2420            *
2421            * @param groupId the group ID
2422            * @param urlTitle the url title
2423            */
2424            public void removeByG_UT(long groupId, java.lang.String urlTitle);
2425    
2426            /**
2427            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
2428            *
2429            * @param groupId the group ID
2430            * @param urlTitle the url title
2431            * @return the number of matching journal articles
2432            */
2433            public int countByG_UT(long groupId, java.lang.String urlTitle);
2434    
2435            /**
2436            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2437            *
2438            * @param groupId the group ID
2439            * @param urlTitle the url title
2440            * @return the number of matching journal articles that the user has permission to view
2441            */
2442            public int filterCountByG_UT(long groupId, java.lang.String urlTitle);
2443    
2444            /**
2445            * Returns all the journal articles where groupId = &#63; and DDMStructureKey = &#63;.
2446            *
2447            * @param groupId the group ID
2448            * @param DDMStructureKey the d d m structure key
2449            * @return the matching journal articles
2450            */
2451            public java.util.List<JournalArticle> findByG_DDMSK(long groupId,
2452                    java.lang.String DDMStructureKey);
2453    
2454            /**
2455            * Returns a range of all the journal articles where groupId = &#63; and DDMStructureKey = &#63;.
2456            *
2457            * <p>
2458            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2459            * </p>
2460            *
2461            * @param groupId the group ID
2462            * @param DDMStructureKey the d d m structure key
2463            * @param start the lower bound of the range of journal articles
2464            * @param end the upper bound of the range of journal articles (not inclusive)
2465            * @return the range of matching journal articles
2466            */
2467            public java.util.List<JournalArticle> findByG_DDMSK(long groupId,
2468                    java.lang.String DDMStructureKey, int start, int end);
2469    
2470            /**
2471            * Returns an ordered range of all the journal articles where groupId = &#63; and DDMStructureKey = &#63;.
2472            *
2473            * <p>
2474            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2475            * </p>
2476            *
2477            * @param groupId the group ID
2478            * @param DDMStructureKey the d d m structure key
2479            * @param start the lower bound of the range of journal articles
2480            * @param end the upper bound of the range of journal articles (not inclusive)
2481            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2482            * @return the ordered range of matching journal articles
2483            */
2484            public java.util.List<JournalArticle> findByG_DDMSK(long groupId,
2485                    java.lang.String DDMStructureKey, int start, int end,
2486                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2487    
2488            /**
2489            * Returns the first journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
2490            *
2491            * @param groupId the group ID
2492            * @param DDMStructureKey the d d m structure key
2493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2494            * @return the first matching journal article
2495            * @throws NoSuchArticleException if a matching journal article could not be found
2496            */
2497            public JournalArticle findByG_DDMSK_First(long groupId,
2498                    java.lang.String DDMStructureKey,
2499                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2500                    throws com.liferay.portlet.journal.NoSuchArticleException;
2501    
2502            /**
2503            * Returns the first journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
2504            *
2505            * @param groupId the group ID
2506            * @param DDMStructureKey the d d m structure key
2507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2508            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2509            */
2510            public JournalArticle fetchByG_DDMSK_First(long groupId,
2511                    java.lang.String DDMStructureKey,
2512                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2513    
2514            /**
2515            * Returns the last journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
2516            *
2517            * @param groupId the group ID
2518            * @param DDMStructureKey the d d m structure key
2519            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2520            * @return the last matching journal article
2521            * @throws NoSuchArticleException if a matching journal article could not be found
2522            */
2523            public JournalArticle findByG_DDMSK_Last(long groupId,
2524                    java.lang.String DDMStructureKey,
2525                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2526                    throws com.liferay.portlet.journal.NoSuchArticleException;
2527    
2528            /**
2529            * Returns the last journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
2530            *
2531            * @param groupId the group ID
2532            * @param DDMStructureKey the d d m structure key
2533            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2534            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2535            */
2536            public JournalArticle fetchByG_DDMSK_Last(long groupId,
2537                    java.lang.String DDMStructureKey,
2538                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2539    
2540            /**
2541            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
2542            *
2543            * @param id the primary key of the current journal article
2544            * @param groupId the group ID
2545            * @param DDMStructureKey the d d m structure key
2546            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2547            * @return the previous, current, and next journal article
2548            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2549            */
2550            public JournalArticle[] findByG_DDMSK_PrevAndNext(long id, long groupId,
2551                    java.lang.String DDMStructureKey,
2552                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2553                    throws com.liferay.portlet.journal.NoSuchArticleException;
2554    
2555            /**
2556            * Returns all the journal articles that the user has permission to view where groupId = &#63; and DDMStructureKey = &#63;.
2557            *
2558            * @param groupId the group ID
2559            * @param DDMStructureKey the d d m structure key
2560            * @return the matching journal articles that the user has permission to view
2561            */
2562            public java.util.List<JournalArticle> filterFindByG_DDMSK(long groupId,
2563                    java.lang.String DDMStructureKey);
2564    
2565            /**
2566            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and DDMStructureKey = &#63;.
2567            *
2568            * <p>
2569            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2570            * </p>
2571            *
2572            * @param groupId the group ID
2573            * @param DDMStructureKey the d d m structure key
2574            * @param start the lower bound of the range of journal articles
2575            * @param end the upper bound of the range of journal articles (not inclusive)
2576            * @return the range of matching journal articles that the user has permission to view
2577            */
2578            public java.util.List<JournalArticle> filterFindByG_DDMSK(long groupId,
2579                    java.lang.String DDMStructureKey, int start, int end);
2580    
2581            /**
2582            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and DDMStructureKey = &#63;.
2583            *
2584            * <p>
2585            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2586            * </p>
2587            *
2588            * @param groupId the group ID
2589            * @param DDMStructureKey the d d m structure key
2590            * @param start the lower bound of the range of journal articles
2591            * @param end the upper bound of the range of journal articles (not inclusive)
2592            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2593            * @return the ordered range of matching journal articles that the user has permission to view
2594            */
2595            public java.util.List<JournalArticle> filterFindByG_DDMSK(long groupId,
2596                    java.lang.String DDMStructureKey, int start, int end,
2597                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2598    
2599            /**
2600            * 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 DDMStructureKey = &#63;.
2601            *
2602            * @param id the primary key of the current journal article
2603            * @param groupId the group ID
2604            * @param DDMStructureKey the d d m structure key
2605            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2606            * @return the previous, current, and next journal article
2607            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2608            */
2609            public JournalArticle[] filterFindByG_DDMSK_PrevAndNext(long id,
2610                    long groupId, java.lang.String DDMStructureKey,
2611                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2612                    throws com.liferay.portlet.journal.NoSuchArticleException;
2613    
2614            /**
2615            * Removes all the journal articles where groupId = &#63; and DDMStructureKey = &#63; from the database.
2616            *
2617            * @param groupId the group ID
2618            * @param DDMStructureKey the d d m structure key
2619            */
2620            public void removeByG_DDMSK(long groupId, java.lang.String DDMStructureKey);
2621    
2622            /**
2623            * Returns the number of journal articles where groupId = &#63; and DDMStructureKey = &#63;.
2624            *
2625            * @param groupId the group ID
2626            * @param DDMStructureKey the d d m structure key
2627            * @return the number of matching journal articles
2628            */
2629            public int countByG_DDMSK(long groupId, java.lang.String DDMStructureKey);
2630    
2631            /**
2632            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and DDMStructureKey = &#63;.
2633            *
2634            * @param groupId the group ID
2635            * @param DDMStructureKey the d d m structure key
2636            * @return the number of matching journal articles that the user has permission to view
2637            */
2638            public int filterCountByG_DDMSK(long groupId,
2639                    java.lang.String DDMStructureKey);
2640    
2641            /**
2642            * Returns all the journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
2643            *
2644            * @param groupId the group ID
2645            * @param DDMTemplateKey the d d m template key
2646            * @return the matching journal articles
2647            */
2648            public java.util.List<JournalArticle> findByG_DDMTK(long groupId,
2649                    java.lang.String DDMTemplateKey);
2650    
2651            /**
2652            * Returns a range of all the journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
2653            *
2654            * <p>
2655            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2656            * </p>
2657            *
2658            * @param groupId the group ID
2659            * @param DDMTemplateKey the d d m template key
2660            * @param start the lower bound of the range of journal articles
2661            * @param end the upper bound of the range of journal articles (not inclusive)
2662            * @return the range of matching journal articles
2663            */
2664            public java.util.List<JournalArticle> findByG_DDMTK(long groupId,
2665                    java.lang.String DDMTemplateKey, int start, int end);
2666    
2667            /**
2668            * Returns an ordered range of all the journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
2669            *
2670            * <p>
2671            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2672            * </p>
2673            *
2674            * @param groupId the group ID
2675            * @param DDMTemplateKey the d d m template key
2676            * @param start the lower bound of the range of journal articles
2677            * @param end the upper bound of the range of journal articles (not inclusive)
2678            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2679            * @return the ordered range of matching journal articles
2680            */
2681            public java.util.List<JournalArticle> findByG_DDMTK(long groupId,
2682                    java.lang.String DDMTemplateKey, int start, int end,
2683                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2684    
2685            /**
2686            * Returns the first journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
2687            *
2688            * @param groupId the group ID
2689            * @param DDMTemplateKey the d d m template key
2690            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2691            * @return the first matching journal article
2692            * @throws NoSuchArticleException if a matching journal article could not be found
2693            */
2694            public JournalArticle findByG_DDMTK_First(long groupId,
2695                    java.lang.String DDMTemplateKey,
2696                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2697                    throws com.liferay.portlet.journal.NoSuchArticleException;
2698    
2699            /**
2700            * Returns the first journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
2701            *
2702            * @param groupId the group ID
2703            * @param DDMTemplateKey the d d m template key
2704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2705            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2706            */
2707            public JournalArticle fetchByG_DDMTK_First(long groupId,
2708                    java.lang.String DDMTemplateKey,
2709                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2710    
2711            /**
2712            * Returns the last journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
2713            *
2714            * @param groupId the group ID
2715            * @param DDMTemplateKey the d d m template key
2716            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2717            * @return the last matching journal article
2718            * @throws NoSuchArticleException if a matching journal article could not be found
2719            */
2720            public JournalArticle findByG_DDMTK_Last(long groupId,
2721                    java.lang.String DDMTemplateKey,
2722                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2723                    throws com.liferay.portlet.journal.NoSuchArticleException;
2724    
2725            /**
2726            * Returns the last journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
2727            *
2728            * @param groupId the group ID
2729            * @param DDMTemplateKey the d d m template key
2730            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2731            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2732            */
2733            public JournalArticle fetchByG_DDMTK_Last(long groupId,
2734                    java.lang.String DDMTemplateKey,
2735                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2736    
2737            /**
2738            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
2739            *
2740            * @param id the primary key of the current journal article
2741            * @param groupId the group ID
2742            * @param DDMTemplateKey the d d m template key
2743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2744            * @return the previous, current, and next journal article
2745            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2746            */
2747            public JournalArticle[] findByG_DDMTK_PrevAndNext(long id, long groupId,
2748                    java.lang.String DDMTemplateKey,
2749                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2750                    throws com.liferay.portlet.journal.NoSuchArticleException;
2751    
2752            /**
2753            * Returns all the journal articles that the user has permission to view where groupId = &#63; and DDMTemplateKey = &#63;.
2754            *
2755            * @param groupId the group ID
2756            * @param DDMTemplateKey the d d m template key
2757            * @return the matching journal articles that the user has permission to view
2758            */
2759            public java.util.List<JournalArticle> filterFindByG_DDMTK(long groupId,
2760                    java.lang.String DDMTemplateKey);
2761    
2762            /**
2763            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and DDMTemplateKey = &#63;.
2764            *
2765            * <p>
2766            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2767            * </p>
2768            *
2769            * @param groupId the group ID
2770            * @param DDMTemplateKey the d d m template key
2771            * @param start the lower bound of the range of journal articles
2772            * @param end the upper bound of the range of journal articles (not inclusive)
2773            * @return the range of matching journal articles that the user has permission to view
2774            */
2775            public java.util.List<JournalArticle> filterFindByG_DDMTK(long groupId,
2776                    java.lang.String DDMTemplateKey, int start, int end);
2777    
2778            /**
2779            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and DDMTemplateKey = &#63;.
2780            *
2781            * <p>
2782            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2783            * </p>
2784            *
2785            * @param groupId the group ID
2786            * @param DDMTemplateKey the d d m template key
2787            * @param start the lower bound of the range of journal articles
2788            * @param end the upper bound of the range of journal articles (not inclusive)
2789            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2790            * @return the ordered range of matching journal articles that the user has permission to view
2791            */
2792            public java.util.List<JournalArticle> filterFindByG_DDMTK(long groupId,
2793                    java.lang.String DDMTemplateKey, int start, int end,
2794                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2795    
2796            /**
2797            * 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 DDMTemplateKey = &#63;.
2798            *
2799            * @param id the primary key of the current journal article
2800            * @param groupId the group ID
2801            * @param DDMTemplateKey the d d m template key
2802            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2803            * @return the previous, current, and next journal article
2804            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2805            */
2806            public JournalArticle[] filterFindByG_DDMTK_PrevAndNext(long id,
2807                    long groupId, java.lang.String DDMTemplateKey,
2808                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2809                    throws com.liferay.portlet.journal.NoSuchArticleException;
2810    
2811            /**
2812            * Removes all the journal articles where groupId = &#63; and DDMTemplateKey = &#63; from the database.
2813            *
2814            * @param groupId the group ID
2815            * @param DDMTemplateKey the d d m template key
2816            */
2817            public void removeByG_DDMTK(long groupId, java.lang.String DDMTemplateKey);
2818    
2819            /**
2820            * Returns the number of journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
2821            *
2822            * @param groupId the group ID
2823            * @param DDMTemplateKey the d d m template key
2824            * @return the number of matching journal articles
2825            */
2826            public int countByG_DDMTK(long groupId, java.lang.String DDMTemplateKey);
2827    
2828            /**
2829            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and DDMTemplateKey = &#63;.
2830            *
2831            * @param groupId the group ID
2832            * @param DDMTemplateKey the d d m template key
2833            * @return the number of matching journal articles that the user has permission to view
2834            */
2835            public int filterCountByG_DDMTK(long groupId,
2836                    java.lang.String DDMTemplateKey);
2837    
2838            /**
2839            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2840            *
2841            * @param groupId the group ID
2842            * @param layoutUuid the layout uuid
2843            * @return the matching journal articles
2844            */
2845            public java.util.List<JournalArticle> findByG_L(long groupId,
2846                    java.lang.String layoutUuid);
2847    
2848            /**
2849            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2850            *
2851            * <p>
2852            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2853            * </p>
2854            *
2855            * @param groupId the group ID
2856            * @param layoutUuid the layout uuid
2857            * @param start the lower bound of the range of journal articles
2858            * @param end the upper bound of the range of journal articles (not inclusive)
2859            * @return the range of matching journal articles
2860            */
2861            public java.util.List<JournalArticle> findByG_L(long groupId,
2862                    java.lang.String layoutUuid, int start, int end);
2863    
2864            /**
2865            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2866            *
2867            * <p>
2868            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2869            * </p>
2870            *
2871            * @param groupId the group ID
2872            * @param layoutUuid the layout uuid
2873            * @param start the lower bound of the range of journal articles
2874            * @param end the upper bound of the range of journal articles (not inclusive)
2875            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2876            * @return the ordered range of matching journal articles
2877            */
2878            public java.util.List<JournalArticle> findByG_L(long groupId,
2879                    java.lang.String layoutUuid, int start, int end,
2880                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2881    
2882            /**
2883            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2884            *
2885            * @param groupId the group ID
2886            * @param layoutUuid the layout uuid
2887            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2888            * @return the first matching journal article
2889            * @throws NoSuchArticleException if a matching journal article could not be found
2890            */
2891            public JournalArticle findByG_L_First(long groupId,
2892                    java.lang.String layoutUuid,
2893                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2894                    throws com.liferay.portlet.journal.NoSuchArticleException;
2895    
2896            /**
2897            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2898            *
2899            * @param groupId the group ID
2900            * @param layoutUuid the layout uuid
2901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2902            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2903            */
2904            public JournalArticle fetchByG_L_First(long groupId,
2905                    java.lang.String layoutUuid,
2906                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2907    
2908            /**
2909            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2910            *
2911            * @param groupId the group ID
2912            * @param layoutUuid the layout uuid
2913            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2914            * @return the last matching journal article
2915            * @throws NoSuchArticleException if a matching journal article could not be found
2916            */
2917            public JournalArticle findByG_L_Last(long groupId,
2918                    java.lang.String layoutUuid,
2919                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2920                    throws com.liferay.portlet.journal.NoSuchArticleException;
2921    
2922            /**
2923            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2924            *
2925            * @param groupId the group ID
2926            * @param layoutUuid the layout uuid
2927            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2928            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2929            */
2930            public JournalArticle fetchByG_L_Last(long groupId,
2931                    java.lang.String layoutUuid,
2932                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2933    
2934            /**
2935            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2936            *
2937            * @param id the primary key of the current journal article
2938            * @param groupId the group ID
2939            * @param layoutUuid the layout uuid
2940            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2941            * @return the previous, current, and next journal article
2942            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2943            */
2944            public JournalArticle[] findByG_L_PrevAndNext(long id, long groupId,
2945                    java.lang.String layoutUuid,
2946                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
2947                    throws com.liferay.portlet.journal.NoSuchArticleException;
2948    
2949            /**
2950            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2951            *
2952            * @param groupId the group ID
2953            * @param layoutUuid the layout uuid
2954            * @return the matching journal articles that the user has permission to view
2955            */
2956            public java.util.List<JournalArticle> filterFindByG_L(long groupId,
2957                    java.lang.String layoutUuid);
2958    
2959            /**
2960            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2961            *
2962            * <p>
2963            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2964            * </p>
2965            *
2966            * @param groupId the group ID
2967            * @param layoutUuid the layout uuid
2968            * @param start the lower bound of the range of journal articles
2969            * @param end the upper bound of the range of journal articles (not inclusive)
2970            * @return the range of matching journal articles that the user has permission to view
2971            */
2972            public java.util.List<JournalArticle> filterFindByG_L(long groupId,
2973                    java.lang.String layoutUuid, int start, int end);
2974    
2975            /**
2976            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
2977            *
2978            * <p>
2979            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2980            * </p>
2981            *
2982            * @param groupId the group ID
2983            * @param layoutUuid the layout uuid
2984            * @param start the lower bound of the range of journal articles
2985            * @param end the upper bound of the range of journal articles (not inclusive)
2986            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2987            * @return the ordered range of matching journal articles that the user has permission to view
2988            */
2989            public java.util.List<JournalArticle> filterFindByG_L(long groupId,
2990                    java.lang.String layoutUuid, int start, int end,
2991                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
2992    
2993            /**
2994            * 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;.
2995            *
2996            * @param id the primary key of the current journal article
2997            * @param groupId the group ID
2998            * @param layoutUuid the layout uuid
2999            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3000            * @return the previous, current, and next journal article
3001            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3002            */
3003            public JournalArticle[] filterFindByG_L_PrevAndNext(long id, long groupId,
3004                    java.lang.String layoutUuid,
3005                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3006                    throws com.liferay.portlet.journal.NoSuchArticleException;
3007    
3008            /**
3009            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
3010            *
3011            * @param groupId the group ID
3012            * @param layoutUuid the layout uuid
3013            */
3014            public void removeByG_L(long groupId, java.lang.String layoutUuid);
3015    
3016            /**
3017            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
3018            *
3019            * @param groupId the group ID
3020            * @param layoutUuid the layout uuid
3021            * @return the number of matching journal articles
3022            */
3023            public int countByG_L(long groupId, java.lang.String layoutUuid);
3024    
3025            /**
3026            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3027            *
3028            * @param groupId the group ID
3029            * @param layoutUuid the layout uuid
3030            * @return the number of matching journal articles that the user has permission to view
3031            */
3032            public int filterCountByG_L(long groupId, java.lang.String layoutUuid);
3033    
3034            /**
3035            * Returns all the journal articles where groupId = &#63; and status = &#63;.
3036            *
3037            * @param groupId the group ID
3038            * @param status the status
3039            * @return the matching journal articles
3040            */
3041            public java.util.List<JournalArticle> findByG_ST(long groupId, int status);
3042    
3043            /**
3044            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
3045            *
3046            * <p>
3047            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3048            * </p>
3049            *
3050            * @param groupId the group ID
3051            * @param status the status
3052            * @param start the lower bound of the range of journal articles
3053            * @param end the upper bound of the range of journal articles (not inclusive)
3054            * @return the range of matching journal articles
3055            */
3056            public java.util.List<JournalArticle> findByG_ST(long groupId, int status,
3057                    int start, int end);
3058    
3059            /**
3060            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
3061            *
3062            * <p>
3063            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3064            * </p>
3065            *
3066            * @param groupId the group ID
3067            * @param status the status
3068            * @param start the lower bound of the range of journal articles
3069            * @param end the upper bound of the range of journal articles (not inclusive)
3070            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3071            * @return the ordered range of matching journal articles
3072            */
3073            public java.util.List<JournalArticle> findByG_ST(long groupId, int status,
3074                    int start, int end,
3075                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3076    
3077            /**
3078            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
3079            *
3080            * @param groupId the group ID
3081            * @param status the status
3082            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3083            * @return the first matching journal article
3084            * @throws NoSuchArticleException if a matching journal article could not be found
3085            */
3086            public JournalArticle findByG_ST_First(long groupId, int status,
3087                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3088                    throws com.liferay.portlet.journal.NoSuchArticleException;
3089    
3090            /**
3091            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
3092            *
3093            * @param groupId the group ID
3094            * @param status the status
3095            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3096            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3097            */
3098            public JournalArticle fetchByG_ST_First(long groupId, int status,
3099                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3100    
3101            /**
3102            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
3103            *
3104            * @param groupId the group ID
3105            * @param status the status
3106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3107            * @return the last matching journal article
3108            * @throws NoSuchArticleException if a matching journal article could not be found
3109            */
3110            public JournalArticle findByG_ST_Last(long groupId, int status,
3111                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3112                    throws com.liferay.portlet.journal.NoSuchArticleException;
3113    
3114            /**
3115            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
3116            *
3117            * @param groupId the group ID
3118            * @param status the status
3119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3120            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3121            */
3122            public JournalArticle fetchByG_ST_Last(long groupId, int status,
3123                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3124    
3125            /**
3126            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
3127            *
3128            * @param id the primary key of the current journal article
3129            * @param groupId the group ID
3130            * @param status the status
3131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3132            * @return the previous, current, and next journal article
3133            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3134            */
3135            public JournalArticle[] findByG_ST_PrevAndNext(long id, long groupId,
3136                    int status,
3137                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3138                    throws com.liferay.portlet.journal.NoSuchArticleException;
3139    
3140            /**
3141            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3142            *
3143            * @param groupId the group ID
3144            * @param status the status
3145            * @return the matching journal articles that the user has permission to view
3146            */
3147            public java.util.List<JournalArticle> filterFindByG_ST(long groupId,
3148                    int status);
3149    
3150            /**
3151            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3152            *
3153            * <p>
3154            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3155            * </p>
3156            *
3157            * @param groupId the group ID
3158            * @param status the status
3159            * @param start the lower bound of the range of journal articles
3160            * @param end the upper bound of the range of journal articles (not inclusive)
3161            * @return the range of matching journal articles that the user has permission to view
3162            */
3163            public java.util.List<JournalArticle> filterFindByG_ST(long groupId,
3164                    int status, int start, int end);
3165    
3166            /**
3167            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
3168            *
3169            * <p>
3170            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3171            * </p>
3172            *
3173            * @param groupId the group ID
3174            * @param status the status
3175            * @param start the lower bound of the range of journal articles
3176            * @param end the upper bound of the range of journal articles (not inclusive)
3177            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3178            * @return the ordered range of matching journal articles that the user has permission to view
3179            */
3180            public java.util.List<JournalArticle> filterFindByG_ST(long groupId,
3181                    int status, int start, int end,
3182                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3183    
3184            /**
3185            * 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;.
3186            *
3187            * @param id the primary key of the current journal article
3188            * @param groupId the group ID
3189            * @param status the status
3190            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3191            * @return the previous, current, and next journal article
3192            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3193            */
3194            public JournalArticle[] filterFindByG_ST_PrevAndNext(long id, long groupId,
3195                    int status,
3196                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3197                    throws com.liferay.portlet.journal.NoSuchArticleException;
3198    
3199            /**
3200            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
3201            *
3202            * @param groupId the group ID
3203            * @param status the status
3204            */
3205            public void removeByG_ST(long groupId, int status);
3206    
3207            /**
3208            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
3209            *
3210            * @param groupId the group ID
3211            * @param status the status
3212            * @return the number of matching journal articles
3213            */
3214            public int countByG_ST(long groupId, int status);
3215    
3216            /**
3217            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3218            *
3219            * @param groupId the group ID
3220            * @param status the status
3221            * @return the number of matching journal articles that the user has permission to view
3222            */
3223            public int filterCountByG_ST(long groupId, int status);
3224    
3225            /**
3226            * Returns all the journal articles where companyId = &#63; and version = &#63;.
3227            *
3228            * @param companyId the company ID
3229            * @param version the version
3230            * @return the matching journal articles
3231            */
3232            public java.util.List<JournalArticle> findByC_V(long companyId,
3233                    double version);
3234    
3235            /**
3236            * Returns a range of all the journal articles where companyId = &#63; and version = &#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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 companyId the company ID
3243            * @param version the version
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            */
3248            public java.util.List<JournalArticle> findByC_V(long companyId,
3249                    double version, int start, int end);
3250    
3251            /**
3252            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
3253            *
3254            * <p>
3255            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3256            * </p>
3257            *
3258            * @param companyId the company ID
3259            * @param version the version
3260            * @param start the lower bound of the range of journal articles
3261            * @param end the upper bound of the range of journal articles (not inclusive)
3262            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3263            * @return the ordered range of matching journal articles
3264            */
3265            public java.util.List<JournalArticle> findByC_V(long companyId,
3266                    double version, int start, int end,
3267                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3268    
3269            /**
3270            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
3271            *
3272            * @param companyId the company ID
3273            * @param version the version
3274            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3275            * @return the first matching journal article
3276            * @throws NoSuchArticleException if a matching journal article could not be found
3277            */
3278            public JournalArticle findByC_V_First(long companyId, double version,
3279                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3280                    throws com.liferay.portlet.journal.NoSuchArticleException;
3281    
3282            /**
3283            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
3284            *
3285            * @param companyId the company ID
3286            * @param version the version
3287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3288            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3289            */
3290            public JournalArticle fetchByC_V_First(long companyId, double version,
3291                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3292    
3293            /**
3294            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
3295            *
3296            * @param companyId the company ID
3297            * @param version the version
3298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3299            * @return the last matching journal article
3300            * @throws NoSuchArticleException if a matching journal article could not be found
3301            */
3302            public JournalArticle findByC_V_Last(long companyId, double version,
3303                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3304                    throws com.liferay.portlet.journal.NoSuchArticleException;
3305    
3306            /**
3307            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
3308            *
3309            * @param companyId the company ID
3310            * @param version the version
3311            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3312            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3313            */
3314            public JournalArticle fetchByC_V_Last(long companyId, double version,
3315                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3316    
3317            /**
3318            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
3319            *
3320            * @param id the primary key of the current journal article
3321            * @param companyId the company ID
3322            * @param version the version
3323            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3324            * @return the previous, current, and next journal article
3325            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3326            */
3327            public JournalArticle[] findByC_V_PrevAndNext(long id, long companyId,
3328                    double version,
3329                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3330                    throws com.liferay.portlet.journal.NoSuchArticleException;
3331    
3332            /**
3333            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
3334            *
3335            * @param companyId the company ID
3336            * @param version the version
3337            */
3338            public void removeByC_V(long companyId, double version);
3339    
3340            /**
3341            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
3342            *
3343            * @param companyId the company ID
3344            * @param version the version
3345            * @return the number of matching journal articles
3346            */
3347            public int countByC_V(long companyId, double version);
3348    
3349            /**
3350            * Returns all the journal articles where companyId = &#63; and status = &#63;.
3351            *
3352            * @param companyId the company ID
3353            * @param status the status
3354            * @return the matching journal articles
3355            */
3356            public java.util.List<JournalArticle> findByC_ST(long companyId, int status);
3357    
3358            /**
3359            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
3360            *
3361            * <p>
3362            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3363            * </p>
3364            *
3365            * @param companyId the company ID
3366            * @param status the status
3367            * @param start the lower bound of the range of journal articles
3368            * @param end the upper bound of the range of journal articles (not inclusive)
3369            * @return the range of matching journal articles
3370            */
3371            public java.util.List<JournalArticle> findByC_ST(long companyId,
3372                    int status, int start, int end);
3373    
3374            /**
3375            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
3376            *
3377            * <p>
3378            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3379            * </p>
3380            *
3381            * @param companyId the company ID
3382            * @param status the status
3383            * @param start the lower bound of the range of journal articles
3384            * @param end the upper bound of the range of journal articles (not inclusive)
3385            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3386            * @return the ordered range of matching journal articles
3387            */
3388            public java.util.List<JournalArticle> findByC_ST(long companyId,
3389                    int status, int start, int end,
3390                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3391    
3392            /**
3393            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
3394            *
3395            * @param companyId the company ID
3396            * @param status the status
3397            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3398            * @return the first matching journal article
3399            * @throws NoSuchArticleException if a matching journal article could not be found
3400            */
3401            public JournalArticle findByC_ST_First(long companyId, int status,
3402                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3403                    throws com.liferay.portlet.journal.NoSuchArticleException;
3404    
3405            /**
3406            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
3407            *
3408            * @param companyId the company ID
3409            * @param status the status
3410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3411            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3412            */
3413            public JournalArticle fetchByC_ST_First(long companyId, int status,
3414                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3415    
3416            /**
3417            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
3418            *
3419            * @param companyId the company ID
3420            * @param status the status
3421            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3422            * @return the last matching journal article
3423            * @throws NoSuchArticleException if a matching journal article could not be found
3424            */
3425            public JournalArticle findByC_ST_Last(long companyId, int status,
3426                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3427                    throws com.liferay.portlet.journal.NoSuchArticleException;
3428    
3429            /**
3430            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
3431            *
3432            * @param companyId the company ID
3433            * @param status the status
3434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3435            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3436            */
3437            public JournalArticle fetchByC_ST_Last(long companyId, int status,
3438                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3439    
3440            /**
3441            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
3442            *
3443            * @param id the primary key of the current journal article
3444            * @param companyId the company ID
3445            * @param status the status
3446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3447            * @return the previous, current, and next journal article
3448            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3449            */
3450            public JournalArticle[] findByC_ST_PrevAndNext(long id, long companyId,
3451                    int status,
3452                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3453                    throws com.liferay.portlet.journal.NoSuchArticleException;
3454    
3455            /**
3456            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
3457            *
3458            * @param companyId the company ID
3459            * @param status the status
3460            */
3461            public void removeByC_ST(long companyId, int status);
3462    
3463            /**
3464            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
3465            *
3466            * @param companyId the company ID
3467            * @param status the status
3468            * @return the number of matching journal articles
3469            */
3470            public int countByC_ST(long companyId, int status);
3471    
3472            /**
3473            * Returns all the journal articles where companyId = &#63; and status &ne; &#63;.
3474            *
3475            * @param companyId the company ID
3476            * @param status the status
3477            * @return the matching journal articles
3478            */
3479            public java.util.List<JournalArticle> findByC_NotST(long companyId,
3480                    int status);
3481    
3482            /**
3483            * Returns a range of all the journal articles where companyId = &#63; and status &ne; &#63;.
3484            *
3485            * <p>
3486            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3487            * </p>
3488            *
3489            * @param companyId the company ID
3490            * @param status the status
3491            * @param start the lower bound of the range of journal articles
3492            * @param end the upper bound of the range of journal articles (not inclusive)
3493            * @return the range of matching journal articles
3494            */
3495            public java.util.List<JournalArticle> findByC_NotST(long companyId,
3496                    int status, int start, int end);
3497    
3498            /**
3499            * Returns an ordered range of all the journal articles where companyId = &#63; and status &ne; &#63;.
3500            *
3501            * <p>
3502            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3503            * </p>
3504            *
3505            * @param companyId the company ID
3506            * @param status the status
3507            * @param start the lower bound of the range of journal articles
3508            * @param end the upper bound of the range of journal articles (not inclusive)
3509            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3510            * @return the ordered range of matching journal articles
3511            */
3512            public java.util.List<JournalArticle> findByC_NotST(long companyId,
3513                    int status, int start, int end,
3514                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3515    
3516            /**
3517            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
3518            *
3519            * @param companyId the company ID
3520            * @param status the status
3521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3522            * @return the first matching journal article
3523            * @throws NoSuchArticleException if a matching journal article could not be found
3524            */
3525            public JournalArticle findByC_NotST_First(long companyId, int status,
3526                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3527                    throws com.liferay.portlet.journal.NoSuchArticleException;
3528    
3529            /**
3530            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
3531            *
3532            * @param companyId the company ID
3533            * @param status the status
3534            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3535            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3536            */
3537            public JournalArticle fetchByC_NotST_First(long companyId, int status,
3538                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3539    
3540            /**
3541            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
3542            *
3543            * @param companyId the company ID
3544            * @param status the status
3545            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3546            * @return the last matching journal article
3547            * @throws NoSuchArticleException if a matching journal article could not be found
3548            */
3549            public JournalArticle findByC_NotST_Last(long companyId, int status,
3550                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3551                    throws com.liferay.portlet.journal.NoSuchArticleException;
3552    
3553            /**
3554            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
3555            *
3556            * @param companyId the company ID
3557            * @param status the status
3558            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3559            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3560            */
3561            public JournalArticle fetchByC_NotST_Last(long companyId, int status,
3562                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3563    
3564            /**
3565            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
3566            *
3567            * @param id the primary key of the current journal article
3568            * @param companyId the company ID
3569            * @param status the status
3570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3571            * @return the previous, current, and next journal article
3572            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3573            */
3574            public JournalArticle[] findByC_NotST_PrevAndNext(long id, long companyId,
3575                    int status,
3576                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3577                    throws com.liferay.portlet.journal.NoSuchArticleException;
3578    
3579            /**
3580            * Removes all the journal articles where companyId = &#63; and status &ne; &#63; from the database.
3581            *
3582            * @param companyId the company ID
3583            * @param status the status
3584            */
3585            public void removeByC_NotST(long companyId, int status);
3586    
3587            /**
3588            * Returns the number of journal articles where companyId = &#63; and status &ne; &#63;.
3589            *
3590            * @param companyId the company ID
3591            * @param status the status
3592            * @return the number of matching journal articles
3593            */
3594            public int countByC_NotST(long companyId, int status);
3595    
3596            /**
3597            * Returns all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
3598            *
3599            * @param classNameId the class name ID
3600            * @param DDMTemplateKey the d d m template key
3601            * @return the matching journal articles
3602            */
3603            public java.util.List<JournalArticle> findByC_DDMTK(long classNameId,
3604                    java.lang.String DDMTemplateKey);
3605    
3606            /**
3607            * Returns a range of all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
3608            *
3609            * <p>
3610            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3611            * </p>
3612            *
3613            * @param classNameId the class name ID
3614            * @param DDMTemplateKey the d d m template key
3615            * @param start the lower bound of the range of journal articles
3616            * @param end the upper bound of the range of journal articles (not inclusive)
3617            * @return the range of matching journal articles
3618            */
3619            public java.util.List<JournalArticle> findByC_DDMTK(long classNameId,
3620                    java.lang.String DDMTemplateKey, int start, int end);
3621    
3622            /**
3623            * Returns an ordered range of all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
3624            *
3625            * <p>
3626            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3627            * </p>
3628            *
3629            * @param classNameId the class name ID
3630            * @param DDMTemplateKey the d d m template key
3631            * @param start the lower bound of the range of journal articles
3632            * @param end the upper bound of the range of journal articles (not inclusive)
3633            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3634            * @return the ordered range of matching journal articles
3635            */
3636            public java.util.List<JournalArticle> findByC_DDMTK(long classNameId,
3637                    java.lang.String DDMTemplateKey, int start, int end,
3638                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3639    
3640            /**
3641            * Returns the first journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
3642            *
3643            * @param classNameId the class name ID
3644            * @param DDMTemplateKey the d d m template key
3645            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3646            * @return the first matching journal article
3647            * @throws NoSuchArticleException if a matching journal article could not be found
3648            */
3649            public JournalArticle findByC_DDMTK_First(long classNameId,
3650                    java.lang.String DDMTemplateKey,
3651                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3652                    throws com.liferay.portlet.journal.NoSuchArticleException;
3653    
3654            /**
3655            * Returns the first journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
3656            *
3657            * @param classNameId the class name ID
3658            * @param DDMTemplateKey the d d m template key
3659            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3660            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3661            */
3662            public JournalArticle fetchByC_DDMTK_First(long classNameId,
3663                    java.lang.String DDMTemplateKey,
3664                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3665    
3666            /**
3667            * Returns the last journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
3668            *
3669            * @param classNameId the class name ID
3670            * @param DDMTemplateKey the d d m template key
3671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3672            * @return the last matching journal article
3673            * @throws NoSuchArticleException if a matching journal article could not be found
3674            */
3675            public JournalArticle findByC_DDMTK_Last(long classNameId,
3676                    java.lang.String DDMTemplateKey,
3677                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3678                    throws com.liferay.portlet.journal.NoSuchArticleException;
3679    
3680            /**
3681            * Returns the last journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
3682            *
3683            * @param classNameId the class name ID
3684            * @param DDMTemplateKey the d d m template key
3685            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3686            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3687            */
3688            public JournalArticle fetchByC_DDMTK_Last(long classNameId,
3689                    java.lang.String DDMTemplateKey,
3690                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3691    
3692            /**
3693            * Returns the journal articles before and after the current journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
3694            *
3695            * @param id the primary key of the current journal article
3696            * @param classNameId the class name ID
3697            * @param DDMTemplateKey the d d m template key
3698            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3699            * @return the previous, current, and next journal article
3700            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3701            */
3702            public JournalArticle[] findByC_DDMTK_PrevAndNext(long id,
3703                    long classNameId, java.lang.String DDMTemplateKey,
3704                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3705                    throws com.liferay.portlet.journal.NoSuchArticleException;
3706    
3707            /**
3708            * Removes all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63; from the database.
3709            *
3710            * @param classNameId the class name ID
3711            * @param DDMTemplateKey the d d m template key
3712            */
3713            public void removeByC_DDMTK(long classNameId,
3714                    java.lang.String DDMTemplateKey);
3715    
3716            /**
3717            * Returns the number of journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
3718            *
3719            * @param classNameId the class name ID
3720            * @param DDMTemplateKey the d d m template key
3721            * @return the number of matching journal articles
3722            */
3723            public int countByC_DDMTK(long classNameId, java.lang.String DDMTemplateKey);
3724    
3725            /**
3726            * Returns all the journal articles where displayDate &lt; &#63; and status = &#63;.
3727            *
3728            * @param displayDate the display date
3729            * @param status the status
3730            * @return the matching journal articles
3731            */
3732            public java.util.List<JournalArticle> findByLtD_S(
3733                    java.util.Date displayDate, int status);
3734    
3735            /**
3736            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
3737            *
3738            * <p>
3739            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3740            * </p>
3741            *
3742            * @param displayDate the display date
3743            * @param status the status
3744            * @param start the lower bound of the range of journal articles
3745            * @param end the upper bound of the range of journal articles (not inclusive)
3746            * @return the range of matching journal articles
3747            */
3748            public java.util.List<JournalArticle> findByLtD_S(
3749                    java.util.Date displayDate, int status, int start, int end);
3750    
3751            /**
3752            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
3753            *
3754            * <p>
3755            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3756            * </p>
3757            *
3758            * @param displayDate the display date
3759            * @param status the status
3760            * @param start the lower bound of the range of journal articles
3761            * @param end the upper bound of the range of journal articles (not inclusive)
3762            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3763            * @return the ordered range of matching journal articles
3764            */
3765            public java.util.List<JournalArticle> findByLtD_S(
3766                    java.util.Date displayDate, int status, int start, int end,
3767                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3768    
3769            /**
3770            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
3771            *
3772            * @param displayDate the display date
3773            * @param status the status
3774            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3775            * @return the first matching journal article
3776            * @throws NoSuchArticleException if a matching journal article could not be found
3777            */
3778            public JournalArticle findByLtD_S_First(java.util.Date displayDate,
3779                    int status,
3780                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3781                    throws com.liferay.portlet.journal.NoSuchArticleException;
3782    
3783            /**
3784            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
3785            *
3786            * @param displayDate the display date
3787            * @param status the status
3788            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3789            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3790            */
3791            public JournalArticle fetchByLtD_S_First(java.util.Date displayDate,
3792                    int status,
3793                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3794    
3795            /**
3796            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
3797            *
3798            * @param displayDate the display date
3799            * @param status the status
3800            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3801            * @return the last matching journal article
3802            * @throws NoSuchArticleException if a matching journal article could not be found
3803            */
3804            public JournalArticle findByLtD_S_Last(java.util.Date displayDate,
3805                    int status,
3806                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3807                    throws com.liferay.portlet.journal.NoSuchArticleException;
3808    
3809            /**
3810            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
3811            *
3812            * @param displayDate the display date
3813            * @param status the status
3814            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3815            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3816            */
3817            public JournalArticle fetchByLtD_S_Last(java.util.Date displayDate,
3818                    int status,
3819                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3820    
3821            /**
3822            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
3823            *
3824            * @param id the primary key of the current journal article
3825            * @param displayDate the display date
3826            * @param status the status
3827            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3828            * @return the previous, current, and next journal article
3829            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3830            */
3831            public JournalArticle[] findByLtD_S_PrevAndNext(long id,
3832                    java.util.Date displayDate, int status,
3833                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3834                    throws com.liferay.portlet.journal.NoSuchArticleException;
3835    
3836            /**
3837            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
3838            *
3839            * @param displayDate the display date
3840            * @param status the status
3841            */
3842            public void removeByLtD_S(java.util.Date displayDate, int status);
3843    
3844            /**
3845            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
3846            *
3847            * @param displayDate the display date
3848            * @param status the status
3849            * @return the number of matching journal articles
3850            */
3851            public int countByLtD_S(java.util.Date displayDate, int status);
3852    
3853            /**
3854            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3855            *
3856            * @param resourcePrimKey the resource prim key
3857            * @param indexable the indexable
3858            * @param status the status
3859            * @return the matching journal articles
3860            */
3861            public java.util.List<JournalArticle> findByR_I_S(long resourcePrimKey,
3862                    boolean indexable, int status);
3863    
3864            /**
3865            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3866            *
3867            * <p>
3868            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3869            * </p>
3870            *
3871            * @param resourcePrimKey the resource prim key
3872            * @param indexable the indexable
3873            * @param status the status
3874            * @param start the lower bound of the range of journal articles
3875            * @param end the upper bound of the range of journal articles (not inclusive)
3876            * @return the range of matching journal articles
3877            */
3878            public java.util.List<JournalArticle> findByR_I_S(long resourcePrimKey,
3879                    boolean indexable, int status, int start, int end);
3880    
3881            /**
3882            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3883            *
3884            * <p>
3885            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3886            * </p>
3887            *
3888            * @param resourcePrimKey the resource prim key
3889            * @param indexable the indexable
3890            * @param status the status
3891            * @param start the lower bound of the range of journal articles
3892            * @param end the upper bound of the range of journal articles (not inclusive)
3893            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3894            * @return the ordered range of matching journal articles
3895            */
3896            public java.util.List<JournalArticle> findByR_I_S(long resourcePrimKey,
3897                    boolean indexable, int status, int start, int end,
3898                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3899    
3900            /**
3901            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3902            *
3903            * @param resourcePrimKey the resource prim key
3904            * @param indexable the indexable
3905            * @param status the status
3906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3907            * @return the first matching journal article
3908            * @throws NoSuchArticleException if a matching journal article could not be found
3909            */
3910            public JournalArticle findByR_I_S_First(long resourcePrimKey,
3911                    boolean indexable, int status,
3912                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3913                    throws com.liferay.portlet.journal.NoSuchArticleException;
3914    
3915            /**
3916            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3917            *
3918            * @param resourcePrimKey the resource prim key
3919            * @param indexable the indexable
3920            * @param status the status
3921            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3922            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3923            */
3924            public JournalArticle fetchByR_I_S_First(long resourcePrimKey,
3925                    boolean indexable, int status,
3926                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3927    
3928            /**
3929            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3930            *
3931            * @param resourcePrimKey the resource prim key
3932            * @param indexable the indexable
3933            * @param status the status
3934            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3935            * @return the last matching journal article
3936            * @throws NoSuchArticleException if a matching journal article could not be found
3937            */
3938            public JournalArticle findByR_I_S_Last(long resourcePrimKey,
3939                    boolean indexable, int status,
3940                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3941                    throws com.liferay.portlet.journal.NoSuchArticleException;
3942    
3943            /**
3944            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3945            *
3946            * @param resourcePrimKey the resource prim key
3947            * @param indexable the indexable
3948            * @param status the status
3949            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3950            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3951            */
3952            public JournalArticle fetchByR_I_S_Last(long resourcePrimKey,
3953                    boolean indexable, int status,
3954                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
3955    
3956            /**
3957            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
3958            *
3959            * @param id the primary key of the current journal article
3960            * @param resourcePrimKey the resource prim key
3961            * @param indexable the indexable
3962            * @param status the status
3963            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3964            * @return the previous, current, and next journal article
3965            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3966            */
3967            public JournalArticle[] findByR_I_S_PrevAndNext(long id,
3968                    long resourcePrimKey, boolean indexable, int status,
3969                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
3970                    throws com.liferay.portlet.journal.NoSuchArticleException;
3971    
3972            /**
3973            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
3974            *
3975            * <p>
3976            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3977            * </p>
3978            *
3979            * @param resourcePrimKey the resource prim key
3980            * @param indexable the indexable
3981            * @param statuses the statuses
3982            * @return the matching journal articles
3983            */
3984            public java.util.List<JournalArticle> findByR_I_S(long resourcePrimKey,
3985                    boolean indexable, int[] statuses);
3986    
3987            /**
3988            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
3989            *
3990            * <p>
3991            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3992            * </p>
3993            *
3994            * @param resourcePrimKey the resource prim key
3995            * @param indexable the indexable
3996            * @param statuses the statuses
3997            * @param start the lower bound of the range of journal articles
3998            * @param end the upper bound of the range of journal articles (not inclusive)
3999            * @return the range of matching journal articles
4000            */
4001            public java.util.List<JournalArticle> findByR_I_S(long resourcePrimKey,
4002                    boolean indexable, int[] statuses, int start, int end);
4003    
4004            /**
4005            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4006            *
4007            * <p>
4008            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4009            * </p>
4010            *
4011            * @param resourcePrimKey the resource prim key
4012            * @param indexable the indexable
4013            * @param statuses the statuses
4014            * @param start the lower bound of the range of journal articles
4015            * @param end the upper bound of the range of journal articles (not inclusive)
4016            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4017            * @return the ordered range of matching journal articles
4018            */
4019            public java.util.List<JournalArticle> findByR_I_S(long resourcePrimKey,
4020                    boolean indexable, int[] statuses, int start, int end,
4021                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4022    
4023            /**
4024            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
4025            *
4026            * @param resourcePrimKey the resource prim key
4027            * @param indexable the indexable
4028            * @param status the status
4029            */
4030            public void removeByR_I_S(long resourcePrimKey, boolean indexable,
4031                    int status);
4032    
4033            /**
4034            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4035            *
4036            * @param resourcePrimKey the resource prim key
4037            * @param indexable the indexable
4038            * @param status the status
4039            * @return the number of matching journal articles
4040            */
4041            public int countByR_I_S(long resourcePrimKey, boolean indexable, int status);
4042    
4043            /**
4044            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4045            *
4046            * @param resourcePrimKey the resource prim key
4047            * @param indexable the indexable
4048            * @param statuses the statuses
4049            * @return the number of matching journal articles
4050            */
4051            public int countByR_I_S(long resourcePrimKey, boolean indexable,
4052                    int[] statuses);
4053    
4054            /**
4055            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4056            *
4057            * @param groupId the group ID
4058            * @param userId the user ID
4059            * @param classNameId the class name ID
4060            * @return the matching journal articles
4061            */
4062            public java.util.List<JournalArticle> findByG_U_C(long groupId,
4063                    long userId, long classNameId);
4064    
4065            /**
4066            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4067            *
4068            * <p>
4069            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4070            * </p>
4071            *
4072            * @param groupId the group ID
4073            * @param userId the user ID
4074            * @param classNameId the class name ID
4075            * @param start the lower bound of the range of journal articles
4076            * @param end the upper bound of the range of journal articles (not inclusive)
4077            * @return the range of matching journal articles
4078            */
4079            public java.util.List<JournalArticle> findByG_U_C(long groupId,
4080                    long userId, long classNameId, int start, int end);
4081    
4082            /**
4083            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4084            *
4085            * <p>
4086            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4087            * </p>
4088            *
4089            * @param groupId the group ID
4090            * @param userId the user ID
4091            * @param classNameId the class name ID
4092            * @param start the lower bound of the range of journal articles
4093            * @param end the upper bound of the range of journal articles (not inclusive)
4094            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4095            * @return the ordered range of matching journal articles
4096            */
4097            public java.util.List<JournalArticle> findByG_U_C(long groupId,
4098                    long userId, long classNameId, int start, int end,
4099                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4100    
4101            /**
4102            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4103            *
4104            * @param groupId the group ID
4105            * @param userId the user ID
4106            * @param classNameId the class name ID
4107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4108            * @return the first matching journal article
4109            * @throws NoSuchArticleException if a matching journal article could not be found
4110            */
4111            public JournalArticle findByG_U_C_First(long groupId, long userId,
4112                    long classNameId,
4113                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4114                    throws com.liferay.portlet.journal.NoSuchArticleException;
4115    
4116            /**
4117            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4118            *
4119            * @param groupId the group ID
4120            * @param userId the user ID
4121            * @param classNameId the class name ID
4122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4123            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4124            */
4125            public JournalArticle fetchByG_U_C_First(long groupId, long userId,
4126                    long classNameId,
4127                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4128    
4129            /**
4130            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4131            *
4132            * @param groupId the group ID
4133            * @param userId the user ID
4134            * @param classNameId the class name ID
4135            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4136            * @return the last matching journal article
4137            * @throws NoSuchArticleException if a matching journal article could not be found
4138            */
4139            public JournalArticle findByG_U_C_Last(long groupId, long userId,
4140                    long classNameId,
4141                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4142                    throws com.liferay.portlet.journal.NoSuchArticleException;
4143    
4144            /**
4145            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4146            *
4147            * @param groupId the group ID
4148            * @param userId the user ID
4149            * @param classNameId the class name ID
4150            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4151            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4152            */
4153            public JournalArticle fetchByG_U_C_Last(long groupId, long userId,
4154                    long classNameId,
4155                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4156    
4157            /**
4158            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4159            *
4160            * @param id the primary key of the current journal article
4161            * @param groupId the group ID
4162            * @param userId the user ID
4163            * @param classNameId the class name ID
4164            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4165            * @return the previous, current, and next journal article
4166            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4167            */
4168            public JournalArticle[] findByG_U_C_PrevAndNext(long id, long groupId,
4169                    long userId, long classNameId,
4170                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4171                    throws com.liferay.portlet.journal.NoSuchArticleException;
4172    
4173            /**
4174            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4175            *
4176            * @param groupId the group ID
4177            * @param userId the user ID
4178            * @param classNameId the class name ID
4179            * @return the matching journal articles that the user has permission to view
4180            */
4181            public java.util.List<JournalArticle> filterFindByG_U_C(long groupId,
4182                    long userId, long classNameId);
4183    
4184            /**
4185            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4186            *
4187            * <p>
4188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4189            * </p>
4190            *
4191            * @param groupId the group ID
4192            * @param userId the user ID
4193            * @param classNameId the class name ID
4194            * @param start the lower bound of the range of journal articles
4195            * @param end the upper bound of the range of journal articles (not inclusive)
4196            * @return the range of matching journal articles that the user has permission to view
4197            */
4198            public java.util.List<JournalArticle> filterFindByG_U_C(long groupId,
4199                    long userId, long classNameId, int start, int end);
4200    
4201            /**
4202            * 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;.
4203            *
4204            * <p>
4205            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4206            * </p>
4207            *
4208            * @param groupId the group ID
4209            * @param userId the user ID
4210            * @param classNameId the class name ID
4211            * @param start the lower bound of the range of journal articles
4212            * @param end the upper bound of the range of journal articles (not inclusive)
4213            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4214            * @return the ordered range of matching journal articles that the user has permission to view
4215            */
4216            public java.util.List<JournalArticle> filterFindByG_U_C(long groupId,
4217                    long userId, long classNameId, int start, int end,
4218                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4219    
4220            /**
4221            * 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;.
4222            *
4223            * @param id the primary key of the current journal article
4224            * @param groupId the group ID
4225            * @param userId the user ID
4226            * @param classNameId the class name ID
4227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4228            * @return the previous, current, and next journal article
4229            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4230            */
4231            public JournalArticle[] filterFindByG_U_C_PrevAndNext(long id,
4232                    long groupId, long userId, long classNameId,
4233                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4234                    throws com.liferay.portlet.journal.NoSuchArticleException;
4235    
4236            /**
4237            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
4238            *
4239            * @param groupId the group ID
4240            * @param userId the user ID
4241            * @param classNameId the class name ID
4242            */
4243            public void removeByG_U_C(long groupId, long userId, long classNameId);
4244    
4245            /**
4246            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4247            *
4248            * @param groupId the group ID
4249            * @param userId the user ID
4250            * @param classNameId the class name ID
4251            * @return the number of matching journal articles
4252            */
4253            public int countByG_U_C(long groupId, long userId, long classNameId);
4254    
4255            /**
4256            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
4257            *
4258            * @param groupId the group ID
4259            * @param userId the user ID
4260            * @param classNameId the class name ID
4261            * @return the number of matching journal articles that the user has permission to view
4262            */
4263            public int filterCountByG_U_C(long groupId, long userId, long classNameId);
4264    
4265            /**
4266            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4267            *
4268            * @param groupId the group ID
4269            * @param folderId the folder ID
4270            * @param status the status
4271            * @return the matching journal articles
4272            */
4273            public java.util.List<JournalArticle> findByG_F_ST(long groupId,
4274                    long folderId, int status);
4275    
4276            /**
4277            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4278            *
4279            * <p>
4280            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4281            * </p>
4282            *
4283            * @param groupId the group ID
4284            * @param folderId the folder ID
4285            * @param status the status
4286            * @param start the lower bound of the range of journal articles
4287            * @param end the upper bound of the range of journal articles (not inclusive)
4288            * @return the range of matching journal articles
4289            */
4290            public java.util.List<JournalArticle> findByG_F_ST(long groupId,
4291                    long folderId, int status, int start, int end);
4292    
4293            /**
4294            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4295            *
4296            * <p>
4297            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4298            * </p>
4299            *
4300            * @param groupId the group ID
4301            * @param folderId the folder ID
4302            * @param status the status
4303            * @param start the lower bound of the range of journal articles
4304            * @param end the upper bound of the range of journal articles (not inclusive)
4305            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4306            * @return the ordered range of matching journal articles
4307            */
4308            public java.util.List<JournalArticle> findByG_F_ST(long groupId,
4309                    long folderId, int status, int start, int end,
4310                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4311    
4312            /**
4313            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4314            *
4315            * @param groupId the group ID
4316            * @param folderId the folder ID
4317            * @param status the status
4318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4319            * @return the first matching journal article
4320            * @throws NoSuchArticleException if a matching journal article could not be found
4321            */
4322            public JournalArticle findByG_F_ST_First(long groupId, long folderId,
4323                    int status,
4324                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4325                    throws com.liferay.portlet.journal.NoSuchArticleException;
4326    
4327            /**
4328            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4329            *
4330            * @param groupId the group ID
4331            * @param folderId the folder ID
4332            * @param status the status
4333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4334            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4335            */
4336            public JournalArticle fetchByG_F_ST_First(long groupId, long folderId,
4337                    int status,
4338                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4339    
4340            /**
4341            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4342            *
4343            * @param groupId the group ID
4344            * @param folderId the folder ID
4345            * @param status the status
4346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4347            * @return the last matching journal article
4348            * @throws NoSuchArticleException if a matching journal article could not be found
4349            */
4350            public JournalArticle findByG_F_ST_Last(long groupId, long folderId,
4351                    int status,
4352                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4353                    throws com.liferay.portlet.journal.NoSuchArticleException;
4354    
4355            /**
4356            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4357            *
4358            * @param groupId the group ID
4359            * @param folderId the folder ID
4360            * @param status the status
4361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4362            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4363            */
4364            public JournalArticle fetchByG_F_ST_Last(long groupId, long folderId,
4365                    int status,
4366                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4367    
4368            /**
4369            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
4370            *
4371            * @param id the primary key of the current journal article
4372            * @param groupId the group ID
4373            * @param folderId the folder ID
4374            * @param status the status
4375            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4376            * @return the previous, current, and next journal article
4377            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4378            */
4379            public JournalArticle[] findByG_F_ST_PrevAndNext(long id, long groupId,
4380                    long folderId, int status,
4381                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4382                    throws com.liferay.portlet.journal.NoSuchArticleException;
4383    
4384            /**
4385            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4386            *
4387            * @param groupId the group ID
4388            * @param folderId the folder ID
4389            * @param status the status
4390            * @return the matching journal articles that the user has permission to view
4391            */
4392            public java.util.List<JournalArticle> filterFindByG_F_ST(long groupId,
4393                    long folderId, int status);
4394    
4395            /**
4396            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4397            *
4398            * <p>
4399            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4400            * </p>
4401            *
4402            * @param groupId the group ID
4403            * @param folderId the folder ID
4404            * @param status the status
4405            * @param start the lower bound of the range of journal articles
4406            * @param end the upper bound of the range of journal articles (not inclusive)
4407            * @return the range of matching journal articles that the user has permission to view
4408            */
4409            public java.util.List<JournalArticle> filterFindByG_F_ST(long groupId,
4410                    long folderId, int status, int start, int end);
4411    
4412            /**
4413            * 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;.
4414            *
4415            * <p>
4416            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4417            * </p>
4418            *
4419            * @param groupId the group ID
4420            * @param folderId the folder ID
4421            * @param status the status
4422            * @param start the lower bound of the range of journal articles
4423            * @param end the upper bound of the range of journal articles (not inclusive)
4424            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4425            * @return the ordered range of matching journal articles that the user has permission to view
4426            */
4427            public java.util.List<JournalArticle> filterFindByG_F_ST(long groupId,
4428                    long folderId, int status, int start, int end,
4429                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4430    
4431            /**
4432            * 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;.
4433            *
4434            * @param id the primary key of the current journal article
4435            * @param groupId the group ID
4436            * @param folderId the folder ID
4437            * @param status the status
4438            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4439            * @return the previous, current, and next journal article
4440            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4441            */
4442            public JournalArticle[] filterFindByG_F_ST_PrevAndNext(long id,
4443                    long groupId, long folderId, int status,
4444                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4445                    throws com.liferay.portlet.journal.NoSuchArticleException;
4446    
4447            /**
4448            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
4449            *
4450            * @param groupId the group ID
4451            * @param folderId the folder ID
4452            * @param statuses the statuses
4453            * @return the matching journal articles that the user has permission to view
4454            */
4455            public java.util.List<JournalArticle> filterFindByG_F_ST(long groupId,
4456                    long folderId, int[] statuses);
4457    
4458            /**
4459            * 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;.
4460            *
4461            * <p>
4462            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4463            * </p>
4464            *
4465            * @param groupId the group ID
4466            * @param folderId the folder ID
4467            * @param statuses the statuses
4468            * @param start the lower bound of the range of journal articles
4469            * @param end the upper bound of the range of journal articles (not inclusive)
4470            * @return the range of matching journal articles that the user has permission to view
4471            */
4472            public java.util.List<JournalArticle> filterFindByG_F_ST(long groupId,
4473                    long folderId, int[] statuses, int start, int end);
4474    
4475            /**
4476            * 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;.
4477            *
4478            * <p>
4479            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4480            * </p>
4481            *
4482            * @param groupId the group ID
4483            * @param folderId the folder ID
4484            * @param statuses the statuses
4485            * @param start the lower bound of the range of journal articles
4486            * @param end the upper bound of the range of journal articles (not inclusive)
4487            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4488            * @return the ordered range of matching journal articles that the user has permission to view
4489            */
4490            public java.util.List<JournalArticle> filterFindByG_F_ST(long groupId,
4491                    long folderId, int[] statuses, int start, int end,
4492                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4493    
4494            /**
4495            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4496            *
4497            * <p>
4498            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4499            * </p>
4500            *
4501            * @param groupId the group ID
4502            * @param folderId the folder ID
4503            * @param statuses the statuses
4504            * @return the matching journal articles
4505            */
4506            public java.util.List<JournalArticle> findByG_F_ST(long groupId,
4507                    long folderId, int[] statuses);
4508    
4509            /**
4510            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4511            *
4512            * <p>
4513            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4514            * </p>
4515            *
4516            * @param groupId the group ID
4517            * @param folderId the folder ID
4518            * @param statuses the statuses
4519            * @param start the lower bound of the range of journal articles
4520            * @param end the upper bound of the range of journal articles (not inclusive)
4521            * @return the range of matching journal articles
4522            */
4523            public java.util.List<JournalArticle> findByG_F_ST(long groupId,
4524                    long folderId, int[] statuses, int start, int end);
4525    
4526            /**
4527            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4528            *
4529            * <p>
4530            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4531            * </p>
4532            *
4533            * @param groupId the group ID
4534            * @param folderId the folder ID
4535            * @param statuses the statuses
4536            * @param start the lower bound of the range of journal articles
4537            * @param end the upper bound of the range of journal articles (not inclusive)
4538            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4539            * @return the ordered range of matching journal articles
4540            */
4541            public java.util.List<JournalArticle> findByG_F_ST(long groupId,
4542                    long folderId, int[] statuses, int start, int end,
4543                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4544    
4545            /**
4546            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
4547            *
4548            * @param groupId the group ID
4549            * @param folderId the folder ID
4550            * @param status the status
4551            */
4552            public void removeByG_F_ST(long groupId, long folderId, int status);
4553    
4554            /**
4555            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
4556            *
4557            * @param groupId the group ID
4558            * @param folderId the folder ID
4559            * @param status the status
4560            * @return the number of matching journal articles
4561            */
4562            public int countByG_F_ST(long groupId, long folderId, int status);
4563    
4564            /**
4565            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
4566            *
4567            * @param groupId the group ID
4568            * @param folderId the folder ID
4569            * @param statuses the statuses
4570            * @return the number of matching journal articles
4571            */
4572            public int countByG_F_ST(long groupId, long folderId, int[] statuses);
4573    
4574            /**
4575            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
4576            *
4577            * @param groupId the group ID
4578            * @param folderId the folder ID
4579            * @param status the status
4580            * @return the number of matching journal articles that the user has permission to view
4581            */
4582            public int filterCountByG_F_ST(long groupId, long folderId, int status);
4583    
4584            /**
4585            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
4586            *
4587            * @param groupId the group ID
4588            * @param folderId the folder ID
4589            * @param statuses the statuses
4590            * @return the number of matching journal articles that the user has permission to view
4591            */
4592            public int filterCountByG_F_ST(long groupId, long folderId, int[] statuses);
4593    
4594            /**
4595            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4596            *
4597            * @param groupId the group ID
4598            * @param classNameId the class name ID
4599            * @param classPK the class p k
4600            * @return the matching journal articles
4601            */
4602            public java.util.List<JournalArticle> findByG_C_C(long groupId,
4603                    long classNameId, long classPK);
4604    
4605            /**
4606            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4607            *
4608            * <p>
4609            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4610            * </p>
4611            *
4612            * @param groupId the group ID
4613            * @param classNameId the class name ID
4614            * @param classPK the class p k
4615            * @param start the lower bound of the range of journal articles
4616            * @param end the upper bound of the range of journal articles (not inclusive)
4617            * @return the range of matching journal articles
4618            */
4619            public java.util.List<JournalArticle> findByG_C_C(long groupId,
4620                    long classNameId, long classPK, int start, int end);
4621    
4622            /**
4623            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4624            *
4625            * <p>
4626            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4627            * </p>
4628            *
4629            * @param groupId the group ID
4630            * @param classNameId the class name ID
4631            * @param classPK the class p k
4632            * @param start the lower bound of the range of journal articles
4633            * @param end the upper bound of the range of journal articles (not inclusive)
4634            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4635            * @return the ordered range of matching journal articles
4636            */
4637            public java.util.List<JournalArticle> findByG_C_C(long groupId,
4638                    long classNameId, long classPK, int start, int end,
4639                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4640    
4641            /**
4642            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4643            *
4644            * @param groupId the group ID
4645            * @param classNameId the class name ID
4646            * @param classPK the class p k
4647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4648            * @return the first matching journal article
4649            * @throws NoSuchArticleException if a matching journal article could not be found
4650            */
4651            public JournalArticle findByG_C_C_First(long groupId, long classNameId,
4652                    long classPK,
4653                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4654                    throws com.liferay.portlet.journal.NoSuchArticleException;
4655    
4656            /**
4657            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4658            *
4659            * @param groupId the group ID
4660            * @param classNameId the class name ID
4661            * @param classPK the class p k
4662            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4663            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4664            */
4665            public JournalArticle fetchByG_C_C_First(long groupId, long classNameId,
4666                    long classPK,
4667                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4668    
4669            /**
4670            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4671            *
4672            * @param groupId the group ID
4673            * @param classNameId the class name ID
4674            * @param classPK the class p k
4675            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4676            * @return the last matching journal article
4677            * @throws NoSuchArticleException if a matching journal article could not be found
4678            */
4679            public JournalArticle findByG_C_C_Last(long groupId, long classNameId,
4680                    long classPK,
4681                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4682                    throws com.liferay.portlet.journal.NoSuchArticleException;
4683    
4684            /**
4685            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4686            *
4687            * @param groupId the group ID
4688            * @param classNameId the class name ID
4689            * @param classPK the class p k
4690            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4691            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4692            */
4693            public JournalArticle fetchByG_C_C_Last(long groupId, long classNameId,
4694                    long classPK,
4695                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4696    
4697            /**
4698            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4699            *
4700            * @param id the primary key of the current journal article
4701            * @param groupId the group ID
4702            * @param classNameId the class name ID
4703            * @param classPK the class p k
4704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4705            * @return the previous, current, and next journal article
4706            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4707            */
4708            public JournalArticle[] findByG_C_C_PrevAndNext(long id, long groupId,
4709                    long classNameId, long classPK,
4710                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4711                    throws com.liferay.portlet.journal.NoSuchArticleException;
4712    
4713            /**
4714            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4715            *
4716            * @param groupId the group ID
4717            * @param classNameId the class name ID
4718            * @param classPK the class p k
4719            * @return the matching journal articles that the user has permission to view
4720            */
4721            public java.util.List<JournalArticle> filterFindByG_C_C(long groupId,
4722                    long classNameId, long classPK);
4723    
4724            /**
4725            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4726            *
4727            * <p>
4728            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4729            * </p>
4730            *
4731            * @param groupId the group ID
4732            * @param classNameId the class name ID
4733            * @param classPK the class p k
4734            * @param start the lower bound of the range of journal articles
4735            * @param end the upper bound of the range of journal articles (not inclusive)
4736            * @return the range of matching journal articles that the user has permission to view
4737            */
4738            public java.util.List<JournalArticle> filterFindByG_C_C(long groupId,
4739                    long classNameId, long classPK, int start, int end);
4740    
4741            /**
4742            * 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;.
4743            *
4744            * <p>
4745            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4746            * </p>
4747            *
4748            * @param groupId the group ID
4749            * @param classNameId the class name ID
4750            * @param classPK the class p k
4751            * @param start the lower bound of the range of journal articles
4752            * @param end the upper bound of the range of journal articles (not inclusive)
4753            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4754            * @return the ordered range of matching journal articles that the user has permission to view
4755            */
4756            public java.util.List<JournalArticle> filterFindByG_C_C(long groupId,
4757                    long classNameId, long classPK, int start, int end,
4758                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4759    
4760            /**
4761            * 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;.
4762            *
4763            * @param id the primary key of the current journal article
4764            * @param groupId the group ID
4765            * @param classNameId the class name ID
4766            * @param classPK the class p k
4767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4768            * @return the previous, current, and next journal article
4769            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4770            */
4771            public JournalArticle[] filterFindByG_C_C_PrevAndNext(long id,
4772                    long groupId, long classNameId, long classPK,
4773                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4774                    throws com.liferay.portlet.journal.NoSuchArticleException;
4775    
4776            /**
4777            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
4778            *
4779            * @param groupId the group ID
4780            * @param classNameId the class name ID
4781            * @param classPK the class p k
4782            */
4783            public void removeByG_C_C(long groupId, long classNameId, long classPK);
4784    
4785            /**
4786            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4787            *
4788            * @param groupId the group ID
4789            * @param classNameId the class name ID
4790            * @param classPK the class p k
4791            * @return the number of matching journal articles
4792            */
4793            public int countByG_C_C(long groupId, long classNameId, long classPK);
4794    
4795            /**
4796            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4797            *
4798            * @param groupId the group ID
4799            * @param classNameId the class name ID
4800            * @param classPK the class p k
4801            * @return the number of matching journal articles that the user has permission to view
4802            */
4803            public int filterCountByG_C_C(long groupId, long classNameId, long classPK);
4804    
4805            /**
4806            * Returns the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; or throws a {@link NoSuchArticleException} if it could not be found.
4807            *
4808            * @param groupId the group ID
4809            * @param classNameId the class name ID
4810            * @param DDMStructureKey the d d m structure key
4811            * @return the matching journal article
4812            * @throws NoSuchArticleException if a matching journal article could not be found
4813            */
4814            public JournalArticle findByG_C_DDMSK(long groupId, long classNameId,
4815                    java.lang.String DDMStructureKey)
4816                    throws com.liferay.portlet.journal.NoSuchArticleException;
4817    
4818            /**
4819            * Returns the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
4820            *
4821            * @param groupId the group ID
4822            * @param classNameId the class name ID
4823            * @param DDMStructureKey the d d m structure key
4824            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
4825            */
4826            public JournalArticle fetchByG_C_DDMSK(long groupId, long classNameId,
4827                    java.lang.String DDMStructureKey);
4828    
4829            /**
4830            * Returns the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
4831            *
4832            * @param groupId the group ID
4833            * @param classNameId the class name ID
4834            * @param DDMStructureKey the d d m structure key
4835            * @param retrieveFromCache whether to use the finder cache
4836            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
4837            */
4838            public JournalArticle fetchByG_C_DDMSK(long groupId, long classNameId,
4839                    java.lang.String DDMStructureKey, boolean retrieveFromCache);
4840    
4841            /**
4842            * Removes the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; from the database.
4843            *
4844            * @param groupId the group ID
4845            * @param classNameId the class name ID
4846            * @param DDMStructureKey the d d m structure key
4847            * @return the journal article that was removed
4848            */
4849            public JournalArticle removeByG_C_DDMSK(long groupId, long classNameId,
4850                    java.lang.String DDMStructureKey)
4851                    throws com.liferay.portlet.journal.NoSuchArticleException;
4852    
4853            /**
4854            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63;.
4855            *
4856            * @param groupId the group ID
4857            * @param classNameId the class name ID
4858            * @param DDMStructureKey the d d m structure key
4859            * @return the number of matching journal articles
4860            */
4861            public int countByG_C_DDMSK(long groupId, long classNameId,
4862                    java.lang.String DDMStructureKey);
4863    
4864            /**
4865            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4866            *
4867            * @param groupId the group ID
4868            * @param classNameId the class name ID
4869            * @param DDMTemplateKey the d d m template key
4870            * @return the matching journal articles
4871            */
4872            public java.util.List<JournalArticle> findByG_C_DDMTK(long groupId,
4873                    long classNameId, java.lang.String DDMTemplateKey);
4874    
4875            /**
4876            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4877            *
4878            * <p>
4879            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4880            * </p>
4881            *
4882            * @param groupId the group ID
4883            * @param classNameId the class name ID
4884            * @param DDMTemplateKey the d d m template key
4885            * @param start the lower bound of the range of journal articles
4886            * @param end the upper bound of the range of journal articles (not inclusive)
4887            * @return the range of matching journal articles
4888            */
4889            public java.util.List<JournalArticle> findByG_C_DDMTK(long groupId,
4890                    long classNameId, java.lang.String DDMTemplateKey, int start, int end);
4891    
4892            /**
4893            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4894            *
4895            * <p>
4896            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4897            * </p>
4898            *
4899            * @param groupId the group ID
4900            * @param classNameId the class name ID
4901            * @param DDMTemplateKey the d d m template key
4902            * @param start the lower bound of the range of journal articles
4903            * @param end the upper bound of the range of journal articles (not inclusive)
4904            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4905            * @return the ordered range of matching journal articles
4906            */
4907            public java.util.List<JournalArticle> findByG_C_DDMTK(long groupId,
4908                    long classNameId, java.lang.String DDMTemplateKey, int start, int end,
4909                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4910    
4911            /**
4912            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4913            *
4914            * @param groupId the group ID
4915            * @param classNameId the class name ID
4916            * @param DDMTemplateKey the d d m template key
4917            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4918            * @return the first matching journal article
4919            * @throws NoSuchArticleException if a matching journal article could not be found
4920            */
4921            public JournalArticle findByG_C_DDMTK_First(long groupId, long classNameId,
4922                    java.lang.String DDMTemplateKey,
4923                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4924                    throws com.liferay.portlet.journal.NoSuchArticleException;
4925    
4926            /**
4927            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4928            *
4929            * @param groupId the group ID
4930            * @param classNameId the class name ID
4931            * @param DDMTemplateKey the d d m template key
4932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4933            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4934            */
4935            public JournalArticle fetchByG_C_DDMTK_First(long groupId,
4936                    long classNameId, java.lang.String DDMTemplateKey,
4937                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4938    
4939            /**
4940            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4941            *
4942            * @param groupId the group ID
4943            * @param classNameId the class name ID
4944            * @param DDMTemplateKey the d d m template key
4945            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4946            * @return the last matching journal article
4947            * @throws NoSuchArticleException if a matching journal article could not be found
4948            */
4949            public JournalArticle findByG_C_DDMTK_Last(long groupId, long classNameId,
4950                    java.lang.String DDMTemplateKey,
4951                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4952                    throws com.liferay.portlet.journal.NoSuchArticleException;
4953    
4954            /**
4955            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4956            *
4957            * @param groupId the group ID
4958            * @param classNameId the class name ID
4959            * @param DDMTemplateKey the d d m template key
4960            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4961            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4962            */
4963            public JournalArticle fetchByG_C_DDMTK_Last(long groupId, long classNameId,
4964                    java.lang.String DDMTemplateKey,
4965                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
4966    
4967            /**
4968            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4969            *
4970            * @param id the primary key of the current journal article
4971            * @param groupId the group ID
4972            * @param classNameId the class name ID
4973            * @param DDMTemplateKey the d d m template key
4974            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4975            * @return the previous, current, and next journal article
4976            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4977            */
4978            public JournalArticle[] findByG_C_DDMTK_PrevAndNext(long id, long groupId,
4979                    long classNameId, java.lang.String DDMTemplateKey,
4980                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
4981                    throws com.liferay.portlet.journal.NoSuchArticleException;
4982    
4983            /**
4984            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4985            *
4986            * @param groupId the group ID
4987            * @param classNameId the class name ID
4988            * @param DDMTemplateKey the d d m template key
4989            * @return the matching journal articles that the user has permission to view
4990            */
4991            public java.util.List<JournalArticle> filterFindByG_C_DDMTK(long groupId,
4992                    long classNameId, java.lang.String DDMTemplateKey);
4993    
4994            /**
4995            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
4996            *
4997            * <p>
4998            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4999            * </p>
5000            *
5001            * @param groupId the group ID
5002            * @param classNameId the class name ID
5003            * @param DDMTemplateKey the d d m template key
5004            * @param start the lower bound of the range of journal articles
5005            * @param end the upper bound of the range of journal articles (not inclusive)
5006            * @return the range of matching journal articles that the user has permission to view
5007            */
5008            public java.util.List<JournalArticle> filterFindByG_C_DDMTK(long groupId,
5009                    long classNameId, java.lang.String DDMTemplateKey, int start, int end);
5010    
5011            /**
5012            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
5013            *
5014            * <p>
5015            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5016            * </p>
5017            *
5018            * @param groupId the group ID
5019            * @param classNameId the class name ID
5020            * @param DDMTemplateKey the d d m template key
5021            * @param start the lower bound of the range of journal articles
5022            * @param end the upper bound of the range of journal articles (not inclusive)
5023            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5024            * @return the ordered range of matching journal articles that the user has permission to view
5025            */
5026            public java.util.List<JournalArticle> filterFindByG_C_DDMTK(long groupId,
5027                    long classNameId, java.lang.String DDMTemplateKey, int start, int end,
5028                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5029    
5030            /**
5031            * 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 DDMTemplateKey = &#63;.
5032            *
5033            * @param id the primary key of the current journal article
5034            * @param groupId the group ID
5035            * @param classNameId the class name ID
5036            * @param DDMTemplateKey the d d m template key
5037            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5038            * @return the previous, current, and next journal article
5039            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5040            */
5041            public JournalArticle[] filterFindByG_C_DDMTK_PrevAndNext(long id,
5042                    long groupId, long classNameId, java.lang.String DDMTemplateKey,
5043                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5044                    throws com.liferay.portlet.journal.NoSuchArticleException;
5045    
5046            /**
5047            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63; from the database.
5048            *
5049            * @param groupId the group ID
5050            * @param classNameId the class name ID
5051            * @param DDMTemplateKey the d d m template key
5052            */
5053            public void removeByG_C_DDMTK(long groupId, long classNameId,
5054                    java.lang.String DDMTemplateKey);
5055    
5056            /**
5057            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
5058            *
5059            * @param groupId the group ID
5060            * @param classNameId the class name ID
5061            * @param DDMTemplateKey the d d m template key
5062            * @return the number of matching journal articles
5063            */
5064            public int countByG_C_DDMTK(long groupId, long classNameId,
5065                    java.lang.String DDMTemplateKey);
5066    
5067            /**
5068            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
5069            *
5070            * @param groupId the group ID
5071            * @param classNameId the class name ID
5072            * @param DDMTemplateKey the d d m template key
5073            * @return the number of matching journal articles that the user has permission to view
5074            */
5075            public int filterCountByG_C_DDMTK(long groupId, long classNameId,
5076                    java.lang.String DDMTemplateKey);
5077    
5078            /**
5079            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5080            *
5081            * @param groupId the group ID
5082            * @param classNameId the class name ID
5083            * @param layoutUuid the layout uuid
5084            * @return the matching journal articles
5085            */
5086            public java.util.List<JournalArticle> findByG_C_L(long groupId,
5087                    long classNameId, java.lang.String layoutUuid);
5088    
5089            /**
5090            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5091            *
5092            * <p>
5093            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5094            * </p>
5095            *
5096            * @param groupId the group ID
5097            * @param classNameId the class name ID
5098            * @param layoutUuid the layout uuid
5099            * @param start the lower bound of the range of journal articles
5100            * @param end the upper bound of the range of journal articles (not inclusive)
5101            * @return the range of matching journal articles
5102            */
5103            public java.util.List<JournalArticle> findByG_C_L(long groupId,
5104                    long classNameId, java.lang.String layoutUuid, int start, int end);
5105    
5106            /**
5107            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5108            *
5109            * <p>
5110            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5111            * </p>
5112            *
5113            * @param groupId the group ID
5114            * @param classNameId the class name ID
5115            * @param layoutUuid the layout uuid
5116            * @param start the lower bound of the range of journal articles
5117            * @param end the upper bound of the range of journal articles (not inclusive)
5118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5119            * @return the ordered range of matching journal articles
5120            */
5121            public java.util.List<JournalArticle> findByG_C_L(long groupId,
5122                    long classNameId, java.lang.String layoutUuid, int start, int end,
5123                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5124    
5125            /**
5126            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5127            *
5128            * @param groupId the group ID
5129            * @param classNameId the class name ID
5130            * @param layoutUuid the layout uuid
5131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5132            * @return the first matching journal article
5133            * @throws NoSuchArticleException if a matching journal article could not be found
5134            */
5135            public JournalArticle findByG_C_L_First(long groupId, long classNameId,
5136                    java.lang.String layoutUuid,
5137                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5138                    throws com.liferay.portlet.journal.NoSuchArticleException;
5139    
5140            /**
5141            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5142            *
5143            * @param groupId the group ID
5144            * @param classNameId the class name ID
5145            * @param layoutUuid the layout uuid
5146            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5147            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5148            */
5149            public JournalArticle fetchByG_C_L_First(long groupId, long classNameId,
5150                    java.lang.String layoutUuid,
5151                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5152    
5153            /**
5154            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5155            *
5156            * @param groupId the group ID
5157            * @param classNameId the class name ID
5158            * @param layoutUuid the layout uuid
5159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5160            * @return the last matching journal article
5161            * @throws NoSuchArticleException if a matching journal article could not be found
5162            */
5163            public JournalArticle findByG_C_L_Last(long groupId, long classNameId,
5164                    java.lang.String layoutUuid,
5165                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5166                    throws com.liferay.portlet.journal.NoSuchArticleException;
5167    
5168            /**
5169            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5170            *
5171            * @param groupId the group ID
5172            * @param classNameId the class name ID
5173            * @param layoutUuid the layout uuid
5174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5175            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5176            */
5177            public JournalArticle fetchByG_C_L_Last(long groupId, long classNameId,
5178                    java.lang.String layoutUuid,
5179                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5180    
5181            /**
5182            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5183            *
5184            * @param id the primary key of the current journal article
5185            * @param groupId the group ID
5186            * @param classNameId the class name ID
5187            * @param layoutUuid the layout uuid
5188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5189            * @return the previous, current, and next journal article
5190            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5191            */
5192            public JournalArticle[] findByG_C_L_PrevAndNext(long id, long groupId,
5193                    long classNameId, java.lang.String layoutUuid,
5194                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5195                    throws com.liferay.portlet.journal.NoSuchArticleException;
5196    
5197            /**
5198            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5199            *
5200            * @param groupId the group ID
5201            * @param classNameId the class name ID
5202            * @param layoutUuid the layout uuid
5203            * @return the matching journal articles that the user has permission to view
5204            */
5205            public java.util.List<JournalArticle> filterFindByG_C_L(long groupId,
5206                    long classNameId, java.lang.String layoutUuid);
5207    
5208            /**
5209            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5210            *
5211            * <p>
5212            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5213            * </p>
5214            *
5215            * @param groupId the group ID
5216            * @param classNameId the class name ID
5217            * @param layoutUuid the layout uuid
5218            * @param start the lower bound of the range of journal articles
5219            * @param end the upper bound of the range of journal articles (not inclusive)
5220            * @return the range of matching journal articles that the user has permission to view
5221            */
5222            public java.util.List<JournalArticle> filterFindByG_C_L(long groupId,
5223                    long classNameId, java.lang.String layoutUuid, int start, int end);
5224    
5225            /**
5226            * 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;.
5227            *
5228            * <p>
5229            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5230            * </p>
5231            *
5232            * @param groupId the group ID
5233            * @param classNameId the class name ID
5234            * @param layoutUuid the layout uuid
5235            * @param start the lower bound of the range of journal articles
5236            * @param end the upper bound of the range of journal articles (not inclusive)
5237            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5238            * @return the ordered range of matching journal articles that the user has permission to view
5239            */
5240            public java.util.List<JournalArticle> filterFindByG_C_L(long groupId,
5241                    long classNameId, java.lang.String layoutUuid, int start, int end,
5242                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5243    
5244            /**
5245            * 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;.
5246            *
5247            * @param id the primary key of the current journal article
5248            * @param groupId the group ID
5249            * @param classNameId the class name ID
5250            * @param layoutUuid the layout uuid
5251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5252            * @return the previous, current, and next journal article
5253            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5254            */
5255            public JournalArticle[] filterFindByG_C_L_PrevAndNext(long id,
5256                    long groupId, long classNameId, java.lang.String layoutUuid,
5257                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5258                    throws com.liferay.portlet.journal.NoSuchArticleException;
5259    
5260            /**
5261            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
5262            *
5263            * @param groupId the group ID
5264            * @param classNameId the class name ID
5265            * @param layoutUuid the layout uuid
5266            */
5267            public void removeByG_C_L(long groupId, long classNameId,
5268                    java.lang.String layoutUuid);
5269    
5270            /**
5271            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5272            *
5273            * @param groupId the group ID
5274            * @param classNameId the class name ID
5275            * @param layoutUuid the layout uuid
5276            * @return the number of matching journal articles
5277            */
5278            public int countByG_C_L(long groupId, long classNameId,
5279                    java.lang.String layoutUuid);
5280    
5281            /**
5282            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5283            *
5284            * @param groupId the group ID
5285            * @param classNameId the class name ID
5286            * @param layoutUuid the layout uuid
5287            * @return the number of matching journal articles that the user has permission to view
5288            */
5289            public int filterCountByG_C_L(long groupId, long classNameId,
5290                    java.lang.String layoutUuid);
5291    
5292            /**
5293            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or throws a {@link NoSuchArticleException} if it could not be found.
5294            *
5295            * @param groupId the group ID
5296            * @param articleId the article ID
5297            * @param version the version
5298            * @return the matching journal article
5299            * @throws NoSuchArticleException if a matching journal article could not be found
5300            */
5301            public JournalArticle findByG_A_V(long groupId, java.lang.String articleId,
5302                    double version)
5303                    throws com.liferay.portlet.journal.NoSuchArticleException;
5304    
5305            /**
5306            * 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.
5307            *
5308            * @param groupId the group ID
5309            * @param articleId the article ID
5310            * @param version the version
5311            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5312            */
5313            public JournalArticle fetchByG_A_V(long groupId,
5314                    java.lang.String articleId, double version);
5315    
5316            /**
5317            * 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.
5318            *
5319            * @param groupId the group ID
5320            * @param articleId the article ID
5321            * @param version the version
5322            * @param retrieveFromCache whether to use the finder cache
5323            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5324            */
5325            public JournalArticle fetchByG_A_V(long groupId,
5326                    java.lang.String articleId, double version, boolean retrieveFromCache);
5327    
5328            /**
5329            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
5330            *
5331            * @param groupId the group ID
5332            * @param articleId the article ID
5333            * @param version the version
5334            * @return the journal article that was removed
5335            */
5336            public JournalArticle removeByG_A_V(long groupId,
5337                    java.lang.String articleId, double version)
5338                    throws com.liferay.portlet.journal.NoSuchArticleException;
5339    
5340            /**
5341            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
5342            *
5343            * @param groupId the group ID
5344            * @param articleId the article ID
5345            * @param version the version
5346            * @return the number of matching journal articles
5347            */
5348            public int countByG_A_V(long groupId, java.lang.String articleId,
5349                    double version);
5350    
5351            /**
5352            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
5353            *
5354            * @param groupId the group ID
5355            * @param articleId the article ID
5356            * @param status the status
5357            * @return the matching journal articles
5358            */
5359            public java.util.List<JournalArticle> findByG_A_ST(long groupId,
5360                    java.lang.String articleId, int status);
5361    
5362            /**
5363            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
5364            *
5365            * <p>
5366            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5367            * </p>
5368            *
5369            * @param groupId the group ID
5370            * @param articleId the article ID
5371            * @param status the status
5372            * @param start the lower bound of the range of journal articles
5373            * @param end the upper bound of the range of journal articles (not inclusive)
5374            * @return the range of matching journal articles
5375            */
5376            public java.util.List<JournalArticle> findByG_A_ST(long groupId,
5377                    java.lang.String articleId, int status, int start, int end);
5378    
5379            /**
5380            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
5381            *
5382            * <p>
5383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5384            * </p>
5385            *
5386            * @param groupId the group ID
5387            * @param articleId the article ID
5388            * @param status the status
5389            * @param start the lower bound of the range of journal articles
5390            * @param end the upper bound of the range of journal articles (not inclusive)
5391            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5392            * @return the ordered range of matching journal articles
5393            */
5394            public java.util.List<JournalArticle> findByG_A_ST(long groupId,
5395                    java.lang.String articleId, int status, int start, int end,
5396                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5397    
5398            /**
5399            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
5400            *
5401            * @param groupId the group ID
5402            * @param articleId the article ID
5403            * @param status the status
5404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5405            * @return the first matching journal article
5406            * @throws NoSuchArticleException if a matching journal article could not be found
5407            */
5408            public JournalArticle findByG_A_ST_First(long groupId,
5409                    java.lang.String articleId, int status,
5410                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5411                    throws com.liferay.portlet.journal.NoSuchArticleException;
5412    
5413            /**
5414            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
5415            *
5416            * @param groupId the group ID
5417            * @param articleId the article ID
5418            * @param status the status
5419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5420            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5421            */
5422            public JournalArticle fetchByG_A_ST_First(long groupId,
5423                    java.lang.String articleId, int status,
5424                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5425    
5426            /**
5427            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
5428            *
5429            * @param groupId the group ID
5430            * @param articleId the article ID
5431            * @param status the status
5432            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5433            * @return the last matching journal article
5434            * @throws NoSuchArticleException if a matching journal article could not be found
5435            */
5436            public JournalArticle findByG_A_ST_Last(long groupId,
5437                    java.lang.String articleId, int status,
5438                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5439                    throws com.liferay.portlet.journal.NoSuchArticleException;
5440    
5441            /**
5442            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
5443            *
5444            * @param groupId the group ID
5445            * @param articleId the article ID
5446            * @param status the status
5447            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5448            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5449            */
5450            public JournalArticle fetchByG_A_ST_Last(long groupId,
5451                    java.lang.String articleId, int status,
5452                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5453    
5454            /**
5455            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
5456            *
5457            * @param id the primary key of the current journal article
5458            * @param groupId the group ID
5459            * @param articleId the article ID
5460            * @param status the status
5461            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5462            * @return the previous, current, and next journal article
5463            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5464            */
5465            public JournalArticle[] findByG_A_ST_PrevAndNext(long id, long groupId,
5466                    java.lang.String articleId, int status,
5467                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5468                    throws com.liferay.portlet.journal.NoSuchArticleException;
5469    
5470            /**
5471            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
5472            *
5473            * @param groupId the group ID
5474            * @param articleId the article ID
5475            * @param status the status
5476            * @return the matching journal articles that the user has permission to view
5477            */
5478            public java.util.List<JournalArticle> filterFindByG_A_ST(long groupId,
5479                    java.lang.String articleId, int status);
5480    
5481            /**
5482            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
5483            *
5484            * <p>
5485            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5486            * </p>
5487            *
5488            * @param groupId the group ID
5489            * @param articleId the article ID
5490            * @param status the status
5491            * @param start the lower bound of the range of journal articles
5492            * @param end the upper bound of the range of journal articles (not inclusive)
5493            * @return the range of matching journal articles that the user has permission to view
5494            */
5495            public java.util.List<JournalArticle> filterFindByG_A_ST(long groupId,
5496                    java.lang.String articleId, int status, int start, int end);
5497    
5498            /**
5499            * 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;.
5500            *
5501            * <p>
5502            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5503            * </p>
5504            *
5505            * @param groupId the group ID
5506            * @param articleId the article ID
5507            * @param status the status
5508            * @param start the lower bound of the range of journal articles
5509            * @param end the upper bound of the range of journal articles (not inclusive)
5510            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5511            * @return the ordered range of matching journal articles that the user has permission to view
5512            */
5513            public java.util.List<JournalArticle> filterFindByG_A_ST(long groupId,
5514                    java.lang.String articleId, int status, int start, int end,
5515                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5516    
5517            /**
5518            * 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;.
5519            *
5520            * @param id the primary key of the current journal article
5521            * @param groupId the group ID
5522            * @param articleId the article ID
5523            * @param status the status
5524            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5525            * @return the previous, current, and next journal article
5526            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5527            */
5528            public JournalArticle[] filterFindByG_A_ST_PrevAndNext(long id,
5529                    long groupId, java.lang.String articleId, int status,
5530                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5531                    throws com.liferay.portlet.journal.NoSuchArticleException;
5532    
5533            /**
5534            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
5535            *
5536            * @param groupId the group ID
5537            * @param articleId the article ID
5538            * @param statuses the statuses
5539            * @return the matching journal articles that the user has permission to view
5540            */
5541            public java.util.List<JournalArticle> filterFindByG_A_ST(long groupId,
5542                    java.lang.String articleId, int[] statuses);
5543    
5544            /**
5545            * 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;.
5546            *
5547            * <p>
5548            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5549            * </p>
5550            *
5551            * @param groupId the group ID
5552            * @param articleId the article ID
5553            * @param statuses the statuses
5554            * @param start the lower bound of the range of journal articles
5555            * @param end the upper bound of the range of journal articles (not inclusive)
5556            * @return the range of matching journal articles that the user has permission to view
5557            */
5558            public java.util.List<JournalArticle> filterFindByG_A_ST(long groupId,
5559                    java.lang.String articleId, int[] statuses, int start, int end);
5560    
5561            /**
5562            * 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;.
5563            *
5564            * <p>
5565            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5566            * </p>
5567            *
5568            * @param groupId the group ID
5569            * @param articleId the article ID
5570            * @param statuses the statuses
5571            * @param start the lower bound of the range of journal articles
5572            * @param end the upper bound of the range of journal articles (not inclusive)
5573            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5574            * @return the ordered range of matching journal articles that the user has permission to view
5575            */
5576            public java.util.List<JournalArticle> filterFindByG_A_ST(long groupId,
5577                    java.lang.String articleId, int[] statuses, int start, int end,
5578                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5579    
5580            /**
5581            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
5582            *
5583            * <p>
5584            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5585            * </p>
5586            *
5587            * @param groupId the group ID
5588            * @param articleId the article ID
5589            * @param statuses the statuses
5590            * @return the matching journal articles
5591            */
5592            public java.util.List<JournalArticle> findByG_A_ST(long groupId,
5593                    java.lang.String articleId, int[] statuses);
5594    
5595            /**
5596            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
5597            *
5598            * <p>
5599            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5600            * </p>
5601            *
5602            * @param groupId the group ID
5603            * @param articleId the article ID
5604            * @param statuses the statuses
5605            * @param start the lower bound of the range of journal articles
5606            * @param end the upper bound of the range of journal articles (not inclusive)
5607            * @return the range of matching journal articles
5608            */
5609            public java.util.List<JournalArticle> findByG_A_ST(long groupId,
5610                    java.lang.String articleId, int[] statuses, int start, int end);
5611    
5612            /**
5613            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
5614            *
5615            * <p>
5616            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5617            * </p>
5618            *
5619            * @param groupId the group ID
5620            * @param articleId the article ID
5621            * @param statuses the statuses
5622            * @param start the lower bound of the range of journal articles
5623            * @param end the upper bound of the range of journal articles (not inclusive)
5624            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5625            * @return the ordered range of matching journal articles
5626            */
5627            public java.util.List<JournalArticle> findByG_A_ST(long groupId,
5628                    java.lang.String articleId, int[] statuses, int start, int end,
5629                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5630    
5631            /**
5632            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
5633            *
5634            * @param groupId the group ID
5635            * @param articleId the article ID
5636            * @param status the status
5637            */
5638            public void removeByG_A_ST(long groupId, java.lang.String articleId,
5639                    int status);
5640    
5641            /**
5642            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
5643            *
5644            * @param groupId the group ID
5645            * @param articleId the article ID
5646            * @param status the status
5647            * @return the number of matching journal articles
5648            */
5649            public int countByG_A_ST(long groupId, java.lang.String articleId,
5650                    int status);
5651    
5652            /**
5653            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
5654            *
5655            * @param groupId the group ID
5656            * @param articleId the article ID
5657            * @param statuses the statuses
5658            * @return the number of matching journal articles
5659            */
5660            public int countByG_A_ST(long groupId, java.lang.String articleId,
5661                    int[] statuses);
5662    
5663            /**
5664            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
5665            *
5666            * @param groupId the group ID
5667            * @param articleId the article ID
5668            * @param status the status
5669            * @return the number of matching journal articles that the user has permission to view
5670            */
5671            public int filterCountByG_A_ST(long groupId, java.lang.String articleId,
5672                    int status);
5673    
5674            /**
5675            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
5676            *
5677            * @param groupId the group ID
5678            * @param articleId the article ID
5679            * @param statuses the statuses
5680            * @return the number of matching journal articles that the user has permission to view
5681            */
5682            public int filterCountByG_A_ST(long groupId, java.lang.String articleId,
5683                    int[] statuses);
5684    
5685            /**
5686            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5687            *
5688            * @param groupId the group ID
5689            * @param articleId the article ID
5690            * @param status the status
5691            * @return the matching journal articles
5692            */
5693            public java.util.List<JournalArticle> findByG_A_NotST(long groupId,
5694                    java.lang.String articleId, int status);
5695    
5696            /**
5697            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5698            *
5699            * <p>
5700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5701            * </p>
5702            *
5703            * @param groupId the group ID
5704            * @param articleId the article ID
5705            * @param status the status
5706            * @param start the lower bound of the range of journal articles
5707            * @param end the upper bound of the range of journal articles (not inclusive)
5708            * @return the range of matching journal articles
5709            */
5710            public java.util.List<JournalArticle> findByG_A_NotST(long groupId,
5711                    java.lang.String articleId, int status, int start, int end);
5712    
5713            /**
5714            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5715            *
5716            * <p>
5717            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5718            * </p>
5719            *
5720            * @param groupId the group ID
5721            * @param articleId the article ID
5722            * @param status the status
5723            * @param start the lower bound of the range of journal articles
5724            * @param end the upper bound of the range of journal articles (not inclusive)
5725            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5726            * @return the ordered range of matching journal articles
5727            */
5728            public java.util.List<JournalArticle> findByG_A_NotST(long groupId,
5729                    java.lang.String articleId, int status, int start, int end,
5730                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5731    
5732            /**
5733            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5734            *
5735            * @param groupId the group ID
5736            * @param articleId the article ID
5737            * @param status the status
5738            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5739            * @return the first matching journal article
5740            * @throws NoSuchArticleException if a matching journal article could not be found
5741            */
5742            public JournalArticle findByG_A_NotST_First(long groupId,
5743                    java.lang.String articleId, int status,
5744                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5745                    throws com.liferay.portlet.journal.NoSuchArticleException;
5746    
5747            /**
5748            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5749            *
5750            * @param groupId the group ID
5751            * @param articleId the article ID
5752            * @param status the status
5753            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5754            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5755            */
5756            public JournalArticle fetchByG_A_NotST_First(long groupId,
5757                    java.lang.String articleId, int status,
5758                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5759    
5760            /**
5761            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5762            *
5763            * @param groupId the group ID
5764            * @param articleId the article ID
5765            * @param status the status
5766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5767            * @return the last matching journal article
5768            * @throws NoSuchArticleException if a matching journal article could not be found
5769            */
5770            public JournalArticle findByG_A_NotST_Last(long groupId,
5771                    java.lang.String articleId, int status,
5772                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5773                    throws com.liferay.portlet.journal.NoSuchArticleException;
5774    
5775            /**
5776            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5777            *
5778            * @param groupId the group ID
5779            * @param articleId the article ID
5780            * @param status the status
5781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5782            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5783            */
5784            public JournalArticle fetchByG_A_NotST_Last(long groupId,
5785                    java.lang.String articleId, int status,
5786                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5787    
5788            /**
5789            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5790            *
5791            * @param id the primary key of the current journal article
5792            * @param groupId the group ID
5793            * @param articleId the article ID
5794            * @param status the status
5795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5796            * @return the previous, current, and next journal article
5797            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5798            */
5799            public JournalArticle[] findByG_A_NotST_PrevAndNext(long id, long groupId,
5800                    java.lang.String articleId, int status,
5801                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5802                    throws com.liferay.portlet.journal.NoSuchArticleException;
5803    
5804            /**
5805            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5806            *
5807            * @param groupId the group ID
5808            * @param articleId the article ID
5809            * @param status the status
5810            * @return the matching journal articles that the user has permission to view
5811            */
5812            public java.util.List<JournalArticle> filterFindByG_A_NotST(long groupId,
5813                    java.lang.String articleId, int status);
5814    
5815            /**
5816            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5817            *
5818            * <p>
5819            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5820            * </p>
5821            *
5822            * @param groupId the group ID
5823            * @param articleId the article ID
5824            * @param status the status
5825            * @param start the lower bound of the range of journal articles
5826            * @param end the upper bound of the range of journal articles (not inclusive)
5827            * @return the range of matching journal articles that the user has permission to view
5828            */
5829            public java.util.List<JournalArticle> filterFindByG_A_NotST(long groupId,
5830                    java.lang.String articleId, int status, int start, int end);
5831    
5832            /**
5833            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5834            *
5835            * <p>
5836            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5837            * </p>
5838            *
5839            * @param groupId the group ID
5840            * @param articleId the article ID
5841            * @param status the status
5842            * @param start the lower bound of the range of journal articles
5843            * @param end the upper bound of the range of journal articles (not inclusive)
5844            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5845            * @return the ordered range of matching journal articles that the user has permission to view
5846            */
5847            public java.util.List<JournalArticle> filterFindByG_A_NotST(long groupId,
5848                    java.lang.String articleId, int status, int start, int end,
5849                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5850    
5851            /**
5852            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5853            *
5854            * @param id the primary key of the current journal article
5855            * @param groupId the group ID
5856            * @param articleId the article ID
5857            * @param status the status
5858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5859            * @return the previous, current, and next journal article
5860            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5861            */
5862            public JournalArticle[] filterFindByG_A_NotST_PrevAndNext(long id,
5863                    long groupId, java.lang.String articleId, int status,
5864                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5865                    throws com.liferay.portlet.journal.NoSuchArticleException;
5866    
5867            /**
5868            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63; from the database.
5869            *
5870            * @param groupId the group ID
5871            * @param articleId the article ID
5872            * @param status the status
5873            */
5874            public void removeByG_A_NotST(long groupId, java.lang.String articleId,
5875                    int status);
5876    
5877            /**
5878            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5879            *
5880            * @param groupId the group ID
5881            * @param articleId the article ID
5882            * @param status the status
5883            * @return the number of matching journal articles
5884            */
5885            public int countByG_A_NotST(long groupId, java.lang.String articleId,
5886                    int status);
5887    
5888            /**
5889            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
5890            *
5891            * @param groupId the group ID
5892            * @param articleId the article ID
5893            * @param status the status
5894            * @return the number of matching journal articles that the user has permission to view
5895            */
5896            public int filterCountByG_A_NotST(long groupId, java.lang.String articleId,
5897                    int status);
5898    
5899            /**
5900            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5901            *
5902            * @param groupId the group ID
5903            * @param urlTitle the url title
5904            * @param status the status
5905            * @return the matching journal articles
5906            */
5907            public java.util.List<JournalArticle> findByG_UT_ST(long groupId,
5908                    java.lang.String urlTitle, int status);
5909    
5910            /**
5911            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5912            *
5913            * <p>
5914            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5915            * </p>
5916            *
5917            * @param groupId the group ID
5918            * @param urlTitle the url title
5919            * @param status the status
5920            * @param start the lower bound of the range of journal articles
5921            * @param end the upper bound of the range of journal articles (not inclusive)
5922            * @return the range of matching journal articles
5923            */
5924            public java.util.List<JournalArticle> findByG_UT_ST(long groupId,
5925                    java.lang.String urlTitle, int status, int start, int end);
5926    
5927            /**
5928            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5929            *
5930            * <p>
5931            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5932            * </p>
5933            *
5934            * @param groupId the group ID
5935            * @param urlTitle the url title
5936            * @param status the status
5937            * @param start the lower bound of the range of journal articles
5938            * @param end the upper bound of the range of journal articles (not inclusive)
5939            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5940            * @return the ordered range of matching journal articles
5941            */
5942            public java.util.List<JournalArticle> findByG_UT_ST(long groupId,
5943                    java.lang.String urlTitle, int status, int start, int end,
5944                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5945    
5946            /**
5947            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5948            *
5949            * @param groupId the group ID
5950            * @param urlTitle the url title
5951            * @param status the status
5952            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5953            * @return the first matching journal article
5954            * @throws NoSuchArticleException if a matching journal article could not be found
5955            */
5956            public JournalArticle findByG_UT_ST_First(long groupId,
5957                    java.lang.String urlTitle, int status,
5958                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5959                    throws com.liferay.portlet.journal.NoSuchArticleException;
5960    
5961            /**
5962            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5963            *
5964            * @param groupId the group ID
5965            * @param urlTitle the url title
5966            * @param status the status
5967            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5968            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5969            */
5970            public JournalArticle fetchByG_UT_ST_First(long groupId,
5971                    java.lang.String urlTitle, int status,
5972                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
5973    
5974            /**
5975            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5976            *
5977            * @param groupId the group ID
5978            * @param urlTitle the url title
5979            * @param status the status
5980            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5981            * @return the last matching journal article
5982            * @throws NoSuchArticleException if a matching journal article could not be found
5983            */
5984            public JournalArticle findByG_UT_ST_Last(long groupId,
5985                    java.lang.String urlTitle, int status,
5986                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
5987                    throws com.liferay.portlet.journal.NoSuchArticleException;
5988    
5989            /**
5990            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5991            *
5992            * @param groupId the group ID
5993            * @param urlTitle the url title
5994            * @param status the status
5995            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5996            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5997            */
5998            public JournalArticle fetchByG_UT_ST_Last(long groupId,
5999                    java.lang.String urlTitle, int status,
6000                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
6001    
6002            /**
6003            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6004            *
6005            * @param id the primary key of the current journal article
6006            * @param groupId the group ID
6007            * @param urlTitle the url title
6008            * @param status the status
6009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6010            * @return the previous, current, and next journal article
6011            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6012            */
6013            public JournalArticle[] findByG_UT_ST_PrevAndNext(long id, long groupId,
6014                    java.lang.String urlTitle, int status,
6015                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
6016                    throws com.liferay.portlet.journal.NoSuchArticleException;
6017    
6018            /**
6019            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6020            *
6021            * @param groupId the group ID
6022            * @param urlTitle the url title
6023            * @param status the status
6024            * @return the matching journal articles that the user has permission to view
6025            */
6026            public java.util.List<JournalArticle> filterFindByG_UT_ST(long groupId,
6027                    java.lang.String urlTitle, int status);
6028    
6029            /**
6030            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6031            *
6032            * <p>
6033            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6034            * </p>
6035            *
6036            * @param groupId the group ID
6037            * @param urlTitle the url title
6038            * @param status the status
6039            * @param start the lower bound of the range of journal articles
6040            * @param end the upper bound of the range of journal articles (not inclusive)
6041            * @return the range of matching journal articles that the user has permission to view
6042            */
6043            public java.util.List<JournalArticle> filterFindByG_UT_ST(long groupId,
6044                    java.lang.String urlTitle, int status, int start, int end);
6045    
6046            /**
6047            * 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;.
6048            *
6049            * <p>
6050            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6051            * </p>
6052            *
6053            * @param groupId the group ID
6054            * @param urlTitle the url title
6055            * @param status the status
6056            * @param start the lower bound of the range of journal articles
6057            * @param end the upper bound of the range of journal articles (not inclusive)
6058            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6059            * @return the ordered range of matching journal articles that the user has permission to view
6060            */
6061            public java.util.List<JournalArticle> filterFindByG_UT_ST(long groupId,
6062                    java.lang.String urlTitle, int status, int start, int end,
6063                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
6064    
6065            /**
6066            * 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;.
6067            *
6068            * @param id the primary key of the current journal article
6069            * @param groupId the group ID
6070            * @param urlTitle the url title
6071            * @param status the status
6072            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6073            * @return the previous, current, and next journal article
6074            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6075            */
6076            public JournalArticle[] filterFindByG_UT_ST_PrevAndNext(long id,
6077                    long groupId, java.lang.String urlTitle, int status,
6078                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
6079                    throws com.liferay.portlet.journal.NoSuchArticleException;
6080    
6081            /**
6082            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
6083            *
6084            * @param groupId the group ID
6085            * @param urlTitle the url title
6086            * @param status the status
6087            */
6088            public void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
6089                    int status);
6090    
6091            /**
6092            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6093            *
6094            * @param groupId the group ID
6095            * @param urlTitle the url title
6096            * @param status the status
6097            * @return the number of matching journal articles
6098            */
6099            public int countByG_UT_ST(long groupId, java.lang.String urlTitle,
6100                    int status);
6101    
6102            /**
6103            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
6104            *
6105            * @param groupId the group ID
6106            * @param urlTitle the url title
6107            * @param status the status
6108            * @return the number of matching journal articles that the user has permission to view
6109            */
6110            public int filterCountByG_UT_ST(long groupId, java.lang.String urlTitle,
6111                    int status);
6112    
6113            /**
6114            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
6115            *
6116            * @param companyId the company ID
6117            * @param version the version
6118            * @param status the status
6119            * @return the matching journal articles
6120            */
6121            public java.util.List<JournalArticle> findByC_V_ST(long companyId,
6122                    double version, int status);
6123    
6124            /**
6125            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
6126            *
6127            * <p>
6128            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6129            * </p>
6130            *
6131            * @param companyId the company ID
6132            * @param version the version
6133            * @param status the status
6134            * @param start the lower bound of the range of journal articles
6135            * @param end the upper bound of the range of journal articles (not inclusive)
6136            * @return the range of matching journal articles
6137            */
6138            public java.util.List<JournalArticle> findByC_V_ST(long companyId,
6139                    double version, int status, int start, int end);
6140    
6141            /**
6142            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
6143            *
6144            * <p>
6145            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6146            * </p>
6147            *
6148            * @param companyId the company ID
6149            * @param version the version
6150            * @param status the status
6151            * @param start the lower bound of the range of journal articles
6152            * @param end the upper bound of the range of journal articles (not inclusive)
6153            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6154            * @return the ordered range of matching journal articles
6155            */
6156            public java.util.List<JournalArticle> findByC_V_ST(long companyId,
6157                    double version, int status, int start, int end,
6158                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
6159    
6160            /**
6161            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
6162            *
6163            * @param companyId the company ID
6164            * @param version the version
6165            * @param status the status
6166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6167            * @return the first matching journal article
6168            * @throws NoSuchArticleException if a matching journal article could not be found
6169            */
6170            public JournalArticle findByC_V_ST_First(long companyId, double version,
6171                    int status,
6172                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
6173                    throws com.liferay.portlet.journal.NoSuchArticleException;
6174    
6175            /**
6176            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
6177            *
6178            * @param companyId the company ID
6179            * @param version the version
6180            * @param status the status
6181            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6182            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6183            */
6184            public JournalArticle fetchByC_V_ST_First(long companyId, double version,
6185                    int status,
6186                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
6187    
6188            /**
6189            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
6190            *
6191            * @param companyId the company ID
6192            * @param version the version
6193            * @param status the status
6194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6195            * @return the last matching journal article
6196            * @throws NoSuchArticleException if a matching journal article could not be found
6197            */
6198            public JournalArticle findByC_V_ST_Last(long companyId, double version,
6199                    int status,
6200                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
6201                    throws com.liferay.portlet.journal.NoSuchArticleException;
6202    
6203            /**
6204            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
6205            *
6206            * @param companyId the company ID
6207            * @param version the version
6208            * @param status the status
6209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6210            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6211            */
6212            public JournalArticle fetchByC_V_ST_Last(long companyId, double version,
6213                    int status,
6214                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
6215    
6216            /**
6217            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
6218            *
6219            * @param id the primary key of the current journal article
6220            * @param companyId the company ID
6221            * @param version the version
6222            * @param status the status
6223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6224            * @return the previous, current, and next journal article
6225            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6226            */
6227            public JournalArticle[] findByC_V_ST_PrevAndNext(long id, long companyId,
6228                    double version, int status,
6229                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator)
6230                    throws com.liferay.portlet.journal.NoSuchArticleException;
6231    
6232            /**
6233            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
6234            *
6235            * @param companyId the company ID
6236            * @param version the version
6237            * @param status the status
6238            */
6239            public void removeByC_V_ST(long companyId, double version, int status);
6240    
6241            /**
6242            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
6243            *
6244            * @param companyId the company ID
6245            * @param version the version
6246            * @param status the status
6247            * @return the number of matching journal articles
6248            */
6249            public int countByC_V_ST(long companyId, double version, int status);
6250    
6251            /**
6252            * Caches the journal article in the entity cache if it is enabled.
6253            *
6254            * @param journalArticle the journal article
6255            */
6256            public void cacheResult(JournalArticle journalArticle);
6257    
6258            /**
6259            * Caches the journal articles in the entity cache if it is enabled.
6260            *
6261            * @param journalArticles the journal articles
6262            */
6263            public void cacheResult(java.util.List<JournalArticle> journalArticles);
6264    
6265            /**
6266            * Creates a new journal article with the primary key. Does not add the journal article to the database.
6267            *
6268            * @param id the primary key for the new journal article
6269            * @return the new journal article
6270            */
6271            public JournalArticle create(long id);
6272    
6273            /**
6274            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
6275            *
6276            * @param id the primary key of the journal article
6277            * @return the journal article that was removed
6278            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6279            */
6280            public JournalArticle remove(long id)
6281                    throws com.liferay.portlet.journal.NoSuchArticleException;
6282    
6283            public JournalArticle updateImpl(JournalArticle journalArticle);
6284    
6285            /**
6286            * Returns the journal article with the primary key or throws a {@link NoSuchArticleException} if it could not be found.
6287            *
6288            * @param id the primary key of the journal article
6289            * @return the journal article
6290            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6291            */
6292            public JournalArticle findByPrimaryKey(long id)
6293                    throws com.liferay.portlet.journal.NoSuchArticleException;
6294    
6295            /**
6296            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
6297            *
6298            * @param id the primary key of the journal article
6299            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
6300            */
6301            public JournalArticle fetchByPrimaryKey(long id);
6302    
6303            @Override
6304            public java.util.Map<java.io.Serializable, JournalArticle> fetchByPrimaryKeys(
6305                    java.util.Set<java.io.Serializable> primaryKeys);
6306    
6307            /**
6308            * Returns all the journal articles.
6309            *
6310            * @return the journal articles
6311            */
6312            public java.util.List<JournalArticle> findAll();
6313    
6314            /**
6315            * Returns a range of all the journal articles.
6316            *
6317            * <p>
6318            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6319            * </p>
6320            *
6321            * @param start the lower bound of the range of journal articles
6322            * @param end the upper bound of the range of journal articles (not inclusive)
6323            * @return the range of journal articles
6324            */
6325            public java.util.List<JournalArticle> findAll(int start, int end);
6326    
6327            /**
6328            * Returns an ordered range of all the journal articles.
6329            *
6330            * <p>
6331            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
6332            * </p>
6333            *
6334            * @param start the lower bound of the range of journal articles
6335            * @param end the upper bound of the range of journal articles (not inclusive)
6336            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6337            * @return the ordered range of journal articles
6338            */
6339            public java.util.List<JournalArticle> findAll(int start, int end,
6340                    com.liferay.portal.kernel.util.OrderByComparator<JournalArticle> orderByComparator);
6341    
6342            /**
6343            * Removes all the journal articles from the database.
6344            */
6345            public void removeAll();
6346    
6347            /**
6348            * Returns the number of journal articles.
6349            *
6350            * @return the number of journal articles
6351            */
6352            public int countAll();
6353    }