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.JournalFolder;
022    
023    /**
024     * The persistence interface for the journal folder 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.JournalFolderPersistenceImpl
032     * @see JournalFolderUtil
033     * @generated
034     */
035    @ProviderType
036    public interface JournalFolderPersistence extends BasePersistence<JournalFolder> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link JournalFolderUtil} to access the journal folder persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the journal folders where uuid = &#63;.
045            *
046            * @param uuid the uuid
047            * @return the matching journal folders
048            */
049            public java.util.List<JournalFolder> findByUuid(java.lang.String uuid);
050    
051            /**
052            * Returns a range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 folders
060            * @param end the upper bound of the range of journal folders (not inclusive)
061            * @return the range of matching journal folders
062            */
063            public java.util.List<JournalFolder> findByUuid(java.lang.String uuid,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 folders
075            * @param end the upper bound of the range of journal folders (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching journal folders
078            */
079            public java.util.List<JournalFolder> findByUuid(java.lang.String uuid,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
082    
083            /**
084            * Returns the first journal folder 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 folder
089            * @throws NoSuchFolderException if a matching journal folder could not be found
090            */
091            public JournalFolder findByUuid_First(java.lang.String uuid,
092                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
093                    throws com.liferay.portlet.journal.NoSuchFolderException;
094    
095            /**
096            * Returns the first journal folder 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 folder, or <code>null</code> if a matching journal folder could not be found
101            */
102            public JournalFolder fetchByUuid_First(java.lang.String uuid,
103                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
104    
105            /**
106            * Returns the last journal folder 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 folder
111            * @throws NoSuchFolderException if a matching journal folder could not be found
112            */
113            public JournalFolder findByUuid_Last(java.lang.String uuid,
114                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
115                    throws com.liferay.portlet.journal.NoSuchFolderException;
116    
117            /**
118            * Returns the last journal folder 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 folder, or <code>null</code> if a matching journal folder could not be found
123            */
124            public JournalFolder fetchByUuid_Last(java.lang.String uuid,
125                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
126    
127            /**
128            * Returns the journal folders before and after the current journal folder in the ordered set where uuid = &#63;.
129            *
130            * @param folderId the primary key of the current journal folder
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 folder
134            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
135            */
136            public JournalFolder[] findByUuid_PrevAndNext(long folderId,
137                    java.lang.String uuid,
138                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
139                    throws com.liferay.portlet.journal.NoSuchFolderException;
140    
141            /**
142            * Removes all the journal folders 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 folders where uuid = &#63;.
150            *
151            * @param uuid the uuid
152            * @return the number of matching journal folders
153            */
154            public int countByUuid(java.lang.String uuid);
155    
156            /**
157            * Returns the journal folder where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
158            *
159            * @param uuid the uuid
160            * @param groupId the group ID
161            * @return the matching journal folder
162            * @throws NoSuchFolderException if a matching journal folder could not be found
163            */
164            public JournalFolder findByUUID_G(java.lang.String uuid, long groupId)
165                    throws com.liferay.portlet.journal.NoSuchFolderException;
166    
167            /**
168            * Returns the journal folder 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 folder, or <code>null</code> if a matching journal folder could not be found
173            */
174            public JournalFolder fetchByUUID_G(java.lang.String uuid, long groupId);
175    
176            /**
177            * Returns the journal folder 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 folder, or <code>null</code> if a matching journal folder could not be found
183            */
184            public JournalFolder fetchByUUID_G(java.lang.String uuid, long groupId,
185                    boolean retrieveFromCache);
186    
187            /**
188            * Removes the journal folder 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 folder that was removed
193            */
194            public JournalFolder removeByUUID_G(java.lang.String uuid, long groupId)
195                    throws com.liferay.portlet.journal.NoSuchFolderException;
196    
197            /**
198            * Returns the number of journal folders 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 folders
203            */
204            public int countByUUID_G(java.lang.String uuid, long groupId);
205    
206            /**
207            * Returns all the journal folders where uuid = &#63; and companyId = &#63;.
208            *
209            * @param uuid the uuid
210            * @param companyId the company ID
211            * @return the matching journal folders
212            */
213            public java.util.List<JournalFolder> findByUuid_C(java.lang.String uuid,
214                    long companyId);
215    
216            /**
217            * Returns a range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 folders
226            * @param end the upper bound of the range of journal folders (not inclusive)
227            * @return the range of matching journal folders
228            */
229            public java.util.List<JournalFolder> findByUuid_C(java.lang.String uuid,
230                    long companyId, int start, int end);
231    
232            /**
233            * Returns an ordered range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 folders
242            * @param end the upper bound of the range of journal folders (not inclusive)
243            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
244            * @return the ordered range of matching journal folders
245            */
246            public java.util.List<JournalFolder> findByUuid_C(java.lang.String uuid,
247                    long companyId, int start, int end,
248                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
249    
250            /**
251            * Returns the first journal folder 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 folder
257            * @throws NoSuchFolderException if a matching journal folder could not be found
258            */
259            public JournalFolder findByUuid_C_First(java.lang.String uuid,
260                    long companyId,
261                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
262                    throws com.liferay.portlet.journal.NoSuchFolderException;
263    
264            /**
265            * Returns the first journal folder 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 folder, or <code>null</code> if a matching journal folder could not be found
271            */
272            public JournalFolder fetchByUuid_C_First(java.lang.String uuid,
273                    long companyId,
274                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
275    
276            /**
277            * Returns the last journal folder 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 folder
283            * @throws NoSuchFolderException if a matching journal folder could not be found
284            */
285            public JournalFolder findByUuid_C_Last(java.lang.String uuid,
286                    long companyId,
287                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
288                    throws com.liferay.portlet.journal.NoSuchFolderException;
289    
290            /**
291            * Returns the last journal folder 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 folder, or <code>null</code> if a matching journal folder could not be found
297            */
298            public JournalFolder fetchByUuid_C_Last(java.lang.String uuid,
299                    long companyId,
300                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
301    
302            /**
303            * Returns the journal folders before and after the current journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
304            *
305            * @param folderId the primary key of the current journal folder
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 folder
310            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
311            */
312            public JournalFolder[] findByUuid_C_PrevAndNext(long folderId,
313                    java.lang.String uuid, long companyId,
314                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
315                    throws com.liferay.portlet.journal.NoSuchFolderException;
316    
317            /**
318            * Removes all the journal folders 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 folders 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 folders
331            */
332            public int countByUuid_C(java.lang.String uuid, long companyId);
333    
334            /**
335            * Returns all the journal folders where groupId = &#63;.
336            *
337            * @param groupId the group ID
338            * @return the matching journal folders
339            */
340            public java.util.List<JournalFolder> findByGroupId(long groupId);
341    
342            /**
343            * Returns a range of all the journal folders where groupId = &#63;.
344            *
345            * <p>
346            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
347            * </p>
348            *
349            * @param groupId the group ID
350            * @param start the lower bound of the range of journal folders
351            * @param end the upper bound of the range of journal folders (not inclusive)
352            * @return the range of matching journal folders
353            */
354            public java.util.List<JournalFolder> findByGroupId(long groupId, int start,
355                    int end);
356    
357            /**
358            * Returns an ordered range of all the journal folders where groupId = &#63;.
359            *
360            * <p>
361            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
362            * </p>
363            *
364            * @param groupId the group ID
365            * @param start the lower bound of the range of journal folders
366            * @param end the upper bound of the range of journal folders (not inclusive)
367            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
368            * @return the ordered range of matching journal folders
369            */
370            public java.util.List<JournalFolder> findByGroupId(long groupId, int start,
371                    int end,
372                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
373    
374            /**
375            * Returns the first journal folder in the ordered set where groupId = &#63;.
376            *
377            * @param groupId the group ID
378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
379            * @return the first matching journal folder
380            * @throws NoSuchFolderException if a matching journal folder could not be found
381            */
382            public JournalFolder findByGroupId_First(long groupId,
383                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
384                    throws com.liferay.portlet.journal.NoSuchFolderException;
385    
386            /**
387            * Returns the first journal folder in the ordered set where groupId = &#63;.
388            *
389            * @param groupId the group ID
390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
391            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
392            */
393            public JournalFolder fetchByGroupId_First(long groupId,
394                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
395    
396            /**
397            * Returns the last journal folder in the ordered set where groupId = &#63;.
398            *
399            * @param groupId the group ID
400            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
401            * @return the last matching journal folder
402            * @throws NoSuchFolderException if a matching journal folder could not be found
403            */
404            public JournalFolder findByGroupId_Last(long groupId,
405                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
406                    throws com.liferay.portlet.journal.NoSuchFolderException;
407    
408            /**
409            * Returns the last journal folder in the ordered set where groupId = &#63;.
410            *
411            * @param groupId the group ID
412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
413            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
414            */
415            public JournalFolder fetchByGroupId_Last(long groupId,
416                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
417    
418            /**
419            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63;.
420            *
421            * @param folderId the primary key of the current journal folder
422            * @param groupId the group ID
423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
424            * @return the previous, current, and next journal folder
425            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
426            */
427            public JournalFolder[] findByGroupId_PrevAndNext(long folderId,
428                    long groupId,
429                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
430                    throws com.liferay.portlet.journal.NoSuchFolderException;
431    
432            /**
433            * Returns all the journal folders that the user has permission to view where groupId = &#63;.
434            *
435            * @param groupId the group ID
436            * @return the matching journal folders that the user has permission to view
437            */
438            public java.util.List<JournalFolder> filterFindByGroupId(long groupId);
439    
440            /**
441            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63;.
442            *
443            * <p>
444            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
445            * </p>
446            *
447            * @param groupId the group ID
448            * @param start the lower bound of the range of journal folders
449            * @param end the upper bound of the range of journal folders (not inclusive)
450            * @return the range of matching journal folders that the user has permission to view
451            */
452            public java.util.List<JournalFolder> filterFindByGroupId(long groupId,
453                    int start, int end);
454    
455            /**
456            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63;.
457            *
458            * <p>
459            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
460            * </p>
461            *
462            * @param groupId the group ID
463            * @param start the lower bound of the range of journal folders
464            * @param end the upper bound of the range of journal folders (not inclusive)
465            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
466            * @return the ordered range of matching journal folders that the user has permission to view
467            */
468            public java.util.List<JournalFolder> filterFindByGroupId(long groupId,
469                    int start, int end,
470                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
471    
472            /**
473            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63;.
474            *
475            * @param folderId the primary key of the current journal folder
476            * @param groupId the group ID
477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
478            * @return the previous, current, and next journal folder
479            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
480            */
481            public JournalFolder[] filterFindByGroupId_PrevAndNext(long folderId,
482                    long groupId,
483                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
484                    throws com.liferay.portlet.journal.NoSuchFolderException;
485    
486            /**
487            * Removes all the journal folders where groupId = &#63; from the database.
488            *
489            * @param groupId the group ID
490            */
491            public void removeByGroupId(long groupId);
492    
493            /**
494            * Returns the number of journal folders where groupId = &#63;.
495            *
496            * @param groupId the group ID
497            * @return the number of matching journal folders
498            */
499            public int countByGroupId(long groupId);
500    
501            /**
502            * Returns the number of journal folders that the user has permission to view where groupId = &#63;.
503            *
504            * @param groupId the group ID
505            * @return the number of matching journal folders that the user has permission to view
506            */
507            public int filterCountByGroupId(long groupId);
508    
509            /**
510            * Returns all the journal folders where companyId = &#63;.
511            *
512            * @param companyId the company ID
513            * @return the matching journal folders
514            */
515            public java.util.List<JournalFolder> findByCompanyId(long companyId);
516    
517            /**
518            * Returns a range of all the journal folders where companyId = &#63;.
519            *
520            * <p>
521            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
522            * </p>
523            *
524            * @param companyId the company ID
525            * @param start the lower bound of the range of journal folders
526            * @param end the upper bound of the range of journal folders (not inclusive)
527            * @return the range of matching journal folders
528            */
529            public java.util.List<JournalFolder> findByCompanyId(long companyId,
530                    int start, int end);
531    
532            /**
533            * Returns an ordered range of all the journal folders where companyId = &#63;.
534            *
535            * <p>
536            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
537            * </p>
538            *
539            * @param companyId the company ID
540            * @param start the lower bound of the range of journal folders
541            * @param end the upper bound of the range of journal folders (not inclusive)
542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
543            * @return the ordered range of matching journal folders
544            */
545            public java.util.List<JournalFolder> findByCompanyId(long companyId,
546                    int start, int end,
547                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
548    
549            /**
550            * Returns the first journal folder in the ordered set where companyId = &#63;.
551            *
552            * @param companyId the company ID
553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
554            * @return the first matching journal folder
555            * @throws NoSuchFolderException if a matching journal folder could not be found
556            */
557            public JournalFolder findByCompanyId_First(long companyId,
558                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
559                    throws com.liferay.portlet.journal.NoSuchFolderException;
560    
561            /**
562            * Returns the first journal folder in the ordered set where companyId = &#63;.
563            *
564            * @param companyId the company ID
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
567            */
568            public JournalFolder fetchByCompanyId_First(long companyId,
569                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
570    
571            /**
572            * Returns the last journal folder in the ordered set where companyId = &#63;.
573            *
574            * @param companyId the company ID
575            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
576            * @return the last matching journal folder
577            * @throws NoSuchFolderException if a matching journal folder could not be found
578            */
579            public JournalFolder findByCompanyId_Last(long companyId,
580                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
581                    throws com.liferay.portlet.journal.NoSuchFolderException;
582    
583            /**
584            * Returns the last journal folder in the ordered set where companyId = &#63;.
585            *
586            * @param companyId the company ID
587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
588            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
589            */
590            public JournalFolder fetchByCompanyId_Last(long companyId,
591                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
592    
593            /**
594            * Returns the journal folders before and after the current journal folder in the ordered set where companyId = &#63;.
595            *
596            * @param folderId the primary key of the current journal folder
597            * @param companyId the company ID
598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
599            * @return the previous, current, and next journal folder
600            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
601            */
602            public JournalFolder[] findByCompanyId_PrevAndNext(long folderId,
603                    long companyId,
604                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
605                    throws com.liferay.portlet.journal.NoSuchFolderException;
606    
607            /**
608            * Removes all the journal folders where companyId = &#63; from the database.
609            *
610            * @param companyId the company ID
611            */
612            public void removeByCompanyId(long companyId);
613    
614            /**
615            * Returns the number of journal folders where companyId = &#63;.
616            *
617            * @param companyId the company ID
618            * @return the number of matching journal folders
619            */
620            public int countByCompanyId(long companyId);
621    
622            /**
623            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63;.
624            *
625            * @param groupId the group ID
626            * @param parentFolderId the parent folder ID
627            * @return the matching journal folders
628            */
629            public java.util.List<JournalFolder> findByG_P(long groupId,
630                    long parentFolderId);
631    
632            /**
633            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63;.
634            *
635            * <p>
636            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
637            * </p>
638            *
639            * @param groupId the group ID
640            * @param parentFolderId the parent folder ID
641            * @param start the lower bound of the range of journal folders
642            * @param end the upper bound of the range of journal folders (not inclusive)
643            * @return the range of matching journal folders
644            */
645            public java.util.List<JournalFolder> findByG_P(long groupId,
646                    long parentFolderId, int start, int end);
647    
648            /**
649            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63;.
650            *
651            * <p>
652            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
653            * </p>
654            *
655            * @param groupId the group ID
656            * @param parentFolderId the parent folder ID
657            * @param start the lower bound of the range of journal folders
658            * @param end the upper bound of the range of journal folders (not inclusive)
659            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
660            * @return the ordered range of matching journal folders
661            */
662            public java.util.List<JournalFolder> findByG_P(long groupId,
663                    long parentFolderId, int start, int end,
664                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
665    
666            /**
667            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
668            *
669            * @param groupId the group ID
670            * @param parentFolderId the parent folder ID
671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
672            * @return the first matching journal folder
673            * @throws NoSuchFolderException if a matching journal folder could not be found
674            */
675            public JournalFolder findByG_P_First(long groupId, long parentFolderId,
676                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
677                    throws com.liferay.portlet.journal.NoSuchFolderException;
678    
679            /**
680            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
681            *
682            * @param groupId the group ID
683            * @param parentFolderId the parent folder ID
684            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
685            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
686            */
687            public JournalFolder fetchByG_P_First(long groupId, long parentFolderId,
688                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
689    
690            /**
691            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
692            *
693            * @param groupId the group ID
694            * @param parentFolderId the parent folder ID
695            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
696            * @return the last matching journal folder
697            * @throws NoSuchFolderException if a matching journal folder could not be found
698            */
699            public JournalFolder findByG_P_Last(long groupId, long parentFolderId,
700                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
701                    throws com.liferay.portlet.journal.NoSuchFolderException;
702    
703            /**
704            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
705            *
706            * @param groupId the group ID
707            * @param parentFolderId the parent folder ID
708            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
709            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
710            */
711            public JournalFolder fetchByG_P_Last(long groupId, long parentFolderId,
712                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
713    
714            /**
715            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
716            *
717            * @param folderId the primary key of the current journal folder
718            * @param groupId the group ID
719            * @param parentFolderId the parent folder ID
720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
721            * @return the previous, current, and next journal folder
722            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
723            */
724            public JournalFolder[] findByG_P_PrevAndNext(long folderId, long groupId,
725                    long parentFolderId,
726                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
727                    throws com.liferay.portlet.journal.NoSuchFolderException;
728    
729            /**
730            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
731            *
732            * @param groupId the group ID
733            * @param parentFolderId the parent folder ID
734            * @return the matching journal folders that the user has permission to view
735            */
736            public java.util.List<JournalFolder> filterFindByG_P(long groupId,
737                    long parentFolderId);
738    
739            /**
740            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
741            *
742            * <p>
743            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
744            * </p>
745            *
746            * @param groupId the group ID
747            * @param parentFolderId the parent folder ID
748            * @param start the lower bound of the range of journal folders
749            * @param end the upper bound of the range of journal folders (not inclusive)
750            * @return the range of matching journal folders that the user has permission to view
751            */
752            public java.util.List<JournalFolder> filterFindByG_P(long groupId,
753                    long parentFolderId, int start, int end);
754    
755            /**
756            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63;.
757            *
758            * <p>
759            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
760            * </p>
761            *
762            * @param groupId the group ID
763            * @param parentFolderId the parent folder ID
764            * @param start the lower bound of the range of journal folders
765            * @param end the upper bound of the range of journal folders (not inclusive)
766            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
767            * @return the ordered range of matching journal folders that the user has permission to view
768            */
769            public java.util.List<JournalFolder> filterFindByG_P(long groupId,
770                    long parentFolderId, int start, int end,
771                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
772    
773            /**
774            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
775            *
776            * @param folderId the primary key of the current journal folder
777            * @param groupId the group ID
778            * @param parentFolderId the parent folder ID
779            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
780            * @return the previous, current, and next journal folder
781            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
782            */
783            public JournalFolder[] filterFindByG_P_PrevAndNext(long folderId,
784                    long groupId, long parentFolderId,
785                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
786                    throws com.liferay.portlet.journal.NoSuchFolderException;
787    
788            /**
789            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; from the database.
790            *
791            * @param groupId the group ID
792            * @param parentFolderId the parent folder ID
793            */
794            public void removeByG_P(long groupId, long parentFolderId);
795    
796            /**
797            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63;.
798            *
799            * @param groupId the group ID
800            * @param parentFolderId the parent folder ID
801            * @return the number of matching journal folders
802            */
803            public int countByG_P(long groupId, long parentFolderId);
804    
805            /**
806            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
807            *
808            * @param groupId the group ID
809            * @param parentFolderId the parent folder ID
810            * @return the number of matching journal folders that the user has permission to view
811            */
812            public int filterCountByG_P(long groupId, long parentFolderId);
813    
814            /**
815            * Returns the journal folder where groupId = &#63; and name = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
816            *
817            * @param groupId the group ID
818            * @param name the name
819            * @return the matching journal folder
820            * @throws NoSuchFolderException if a matching journal folder could not be found
821            */
822            public JournalFolder findByG_N(long groupId, java.lang.String name)
823                    throws com.liferay.portlet.journal.NoSuchFolderException;
824    
825            /**
826            * Returns the journal folder where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
827            *
828            * @param groupId the group ID
829            * @param name the name
830            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
831            */
832            public JournalFolder fetchByG_N(long groupId, java.lang.String name);
833    
834            /**
835            * Returns the journal folder where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
836            *
837            * @param groupId the group ID
838            * @param name the name
839            * @param retrieveFromCache whether to use the finder cache
840            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
841            */
842            public JournalFolder fetchByG_N(long groupId, java.lang.String name,
843                    boolean retrieveFromCache);
844    
845            /**
846            * Removes the journal folder where groupId = &#63; and name = &#63; from the database.
847            *
848            * @param groupId the group ID
849            * @param name the name
850            * @return the journal folder that was removed
851            */
852            public JournalFolder removeByG_N(long groupId, java.lang.String name)
853                    throws com.liferay.portlet.journal.NoSuchFolderException;
854    
855            /**
856            * Returns the number of journal folders where groupId = &#63; and name = &#63;.
857            *
858            * @param groupId the group ID
859            * @param name the name
860            * @return the number of matching journal folders
861            */
862            public int countByG_N(long groupId, java.lang.String name);
863    
864            /**
865            * Returns all the journal folders where companyId = &#63; and status &ne; &#63;.
866            *
867            * @param companyId the company ID
868            * @param status the status
869            * @return the matching journal folders
870            */
871            public java.util.List<JournalFolder> findByC_NotS(long companyId, int status);
872    
873            /**
874            * Returns a range of all the journal folders where companyId = &#63; and status &ne; &#63;.
875            *
876            * <p>
877            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
878            * </p>
879            *
880            * @param companyId the company ID
881            * @param status the status
882            * @param start the lower bound of the range of journal folders
883            * @param end the upper bound of the range of journal folders (not inclusive)
884            * @return the range of matching journal folders
885            */
886            public java.util.List<JournalFolder> findByC_NotS(long companyId,
887                    int status, int start, int end);
888    
889            /**
890            * Returns an ordered range of all the journal folders where companyId = &#63; and status &ne; &#63;.
891            *
892            * <p>
893            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
894            * </p>
895            *
896            * @param companyId the company ID
897            * @param status the status
898            * @param start the lower bound of the range of journal folders
899            * @param end the upper bound of the range of journal folders (not inclusive)
900            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
901            * @return the ordered range of matching journal folders
902            */
903            public java.util.List<JournalFolder> findByC_NotS(long companyId,
904                    int status, int start, int end,
905                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
906    
907            /**
908            * Returns the first journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
909            *
910            * @param companyId the company ID
911            * @param status the status
912            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
913            * @return the first matching journal folder
914            * @throws NoSuchFolderException if a matching journal folder could not be found
915            */
916            public JournalFolder findByC_NotS_First(long companyId, int status,
917                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
918                    throws com.liferay.portlet.journal.NoSuchFolderException;
919    
920            /**
921            * Returns the first journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
922            *
923            * @param companyId the company ID
924            * @param status the status
925            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
926            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
927            */
928            public JournalFolder fetchByC_NotS_First(long companyId, int status,
929                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
930    
931            /**
932            * Returns the last journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
933            *
934            * @param companyId the company ID
935            * @param status the status
936            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
937            * @return the last matching journal folder
938            * @throws NoSuchFolderException if a matching journal folder could not be found
939            */
940            public JournalFolder findByC_NotS_Last(long companyId, int status,
941                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
942                    throws com.liferay.portlet.journal.NoSuchFolderException;
943    
944            /**
945            * Returns the last journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
946            *
947            * @param companyId the company ID
948            * @param status the status
949            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
950            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
951            */
952            public JournalFolder fetchByC_NotS_Last(long companyId, int status,
953                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
954    
955            /**
956            * Returns the journal folders before and after the current journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
957            *
958            * @param folderId the primary key of the current journal folder
959            * @param companyId the company ID
960            * @param status the status
961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
962            * @return the previous, current, and next journal folder
963            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
964            */
965            public JournalFolder[] findByC_NotS_PrevAndNext(long folderId,
966                    long companyId, int status,
967                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
968                    throws com.liferay.portlet.journal.NoSuchFolderException;
969    
970            /**
971            * Removes all the journal folders where companyId = &#63; and status &ne; &#63; from the database.
972            *
973            * @param companyId the company ID
974            * @param status the status
975            */
976            public void removeByC_NotS(long companyId, int status);
977    
978            /**
979            * Returns the number of journal folders where companyId = &#63; and status &ne; &#63;.
980            *
981            * @param companyId the company ID
982            * @param status the status
983            * @return the number of matching journal folders
984            */
985            public int countByC_NotS(long companyId, int status);
986    
987            /**
988            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
989            *
990            * @param groupId the group ID
991            * @param parentFolderId the parent folder ID
992            * @param name the name
993            * @return the matching journal folder
994            * @throws NoSuchFolderException if a matching journal folder could not be found
995            */
996            public JournalFolder findByG_P_N(long groupId, long parentFolderId,
997                    java.lang.String name)
998                    throws com.liferay.portlet.journal.NoSuchFolderException;
999    
1000            /**
1001            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1002            *
1003            * @param groupId the group ID
1004            * @param parentFolderId the parent folder ID
1005            * @param name the name
1006            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1007            */
1008            public JournalFolder fetchByG_P_N(long groupId, long parentFolderId,
1009                    java.lang.String name);
1010    
1011            /**
1012            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1013            *
1014            * @param groupId the group ID
1015            * @param parentFolderId the parent folder ID
1016            * @param name the name
1017            * @param retrieveFromCache whether to use the finder cache
1018            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1019            */
1020            public JournalFolder fetchByG_P_N(long groupId, long parentFolderId,
1021                    java.lang.String name, boolean retrieveFromCache);
1022    
1023            /**
1024            * Removes the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; from the database.
1025            *
1026            * @param groupId the group ID
1027            * @param parentFolderId the parent folder ID
1028            * @param name the name
1029            * @return the journal folder that was removed
1030            */
1031            public JournalFolder removeByG_P_N(long groupId, long parentFolderId,
1032                    java.lang.String name)
1033                    throws com.liferay.portlet.journal.NoSuchFolderException;
1034    
1035            /**
1036            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and name = &#63;.
1037            *
1038            * @param groupId the group ID
1039            * @param parentFolderId the parent folder ID
1040            * @param name the name
1041            * @return the number of matching journal folders
1042            */
1043            public int countByG_P_N(long groupId, long parentFolderId,
1044                    java.lang.String name);
1045    
1046            /**
1047            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1048            *
1049            * @param groupId the group ID
1050            * @param parentFolderId the parent folder ID
1051            * @param status the status
1052            * @return the matching journal folders
1053            */
1054            public java.util.List<JournalFolder> findByG_P_S(long groupId,
1055                    long parentFolderId, int status);
1056    
1057            /**
1058            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1059            *
1060            * <p>
1061            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1062            * </p>
1063            *
1064            * @param groupId the group ID
1065            * @param parentFolderId the parent folder ID
1066            * @param status the status
1067            * @param start the lower bound of the range of journal folders
1068            * @param end the upper bound of the range of journal folders (not inclusive)
1069            * @return the range of matching journal folders
1070            */
1071            public java.util.List<JournalFolder> findByG_P_S(long groupId,
1072                    long parentFolderId, int status, int start, int end);
1073    
1074            /**
1075            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1076            *
1077            * <p>
1078            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1079            * </p>
1080            *
1081            * @param groupId the group ID
1082            * @param parentFolderId the parent folder ID
1083            * @param status the status
1084            * @param start the lower bound of the range of journal folders
1085            * @param end the upper bound of the range of journal folders (not inclusive)
1086            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1087            * @return the ordered range of matching journal folders
1088            */
1089            public java.util.List<JournalFolder> findByG_P_S(long groupId,
1090                    long parentFolderId, int status, int start, int end,
1091                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1092    
1093            /**
1094            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1095            *
1096            * @param groupId the group ID
1097            * @param parentFolderId the parent folder ID
1098            * @param status the status
1099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1100            * @return the first matching journal folder
1101            * @throws NoSuchFolderException if a matching journal folder could not be found
1102            */
1103            public JournalFolder findByG_P_S_First(long groupId, long parentFolderId,
1104                    int status,
1105                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1106                    throws com.liferay.portlet.journal.NoSuchFolderException;
1107    
1108            /**
1109            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1110            *
1111            * @param groupId the group ID
1112            * @param parentFolderId the parent folder ID
1113            * @param status the status
1114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1115            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1116            */
1117            public JournalFolder fetchByG_P_S_First(long groupId, long parentFolderId,
1118                    int status,
1119                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1120    
1121            /**
1122            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1123            *
1124            * @param groupId the group ID
1125            * @param parentFolderId the parent folder ID
1126            * @param status the status
1127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1128            * @return the last matching journal folder
1129            * @throws NoSuchFolderException if a matching journal folder could not be found
1130            */
1131            public JournalFolder findByG_P_S_Last(long groupId, long parentFolderId,
1132                    int status,
1133                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1134                    throws com.liferay.portlet.journal.NoSuchFolderException;
1135    
1136            /**
1137            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1138            *
1139            * @param groupId the group ID
1140            * @param parentFolderId the parent folder ID
1141            * @param status the status
1142            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1143            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1144            */
1145            public JournalFolder fetchByG_P_S_Last(long groupId, long parentFolderId,
1146                    int status,
1147                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1148    
1149            /**
1150            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1151            *
1152            * @param folderId the primary key of the current journal folder
1153            * @param groupId the group ID
1154            * @param parentFolderId the parent folder ID
1155            * @param status the status
1156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1157            * @return the previous, current, and next journal folder
1158            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1159            */
1160            public JournalFolder[] findByG_P_S_PrevAndNext(long folderId, long groupId,
1161                    long parentFolderId, int status,
1162                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1163                    throws com.liferay.portlet.journal.NoSuchFolderException;
1164    
1165            /**
1166            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1167            *
1168            * @param groupId the group ID
1169            * @param parentFolderId the parent folder ID
1170            * @param status the status
1171            * @return the matching journal folders that the user has permission to view
1172            */
1173            public java.util.List<JournalFolder> filterFindByG_P_S(long groupId,
1174                    long parentFolderId, int status);
1175    
1176            /**
1177            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1178            *
1179            * <p>
1180            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1181            * </p>
1182            *
1183            * @param groupId the group ID
1184            * @param parentFolderId the parent folder ID
1185            * @param status the status
1186            * @param start the lower bound of the range of journal folders
1187            * @param end the upper bound of the range of journal folders (not inclusive)
1188            * @return the range of matching journal folders that the user has permission to view
1189            */
1190            public java.util.List<JournalFolder> filterFindByG_P_S(long groupId,
1191                    long parentFolderId, int status, int start, int end);
1192    
1193            /**
1194            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1195            *
1196            * <p>
1197            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1198            * </p>
1199            *
1200            * @param groupId the group ID
1201            * @param parentFolderId the parent folder ID
1202            * @param status the status
1203            * @param start the lower bound of the range of journal folders
1204            * @param end the upper bound of the range of journal folders (not inclusive)
1205            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1206            * @return the ordered range of matching journal folders that the user has permission to view
1207            */
1208            public java.util.List<JournalFolder> filterFindByG_P_S(long groupId,
1209                    long parentFolderId, int status, int start, int end,
1210                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1211    
1212            /**
1213            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1214            *
1215            * @param folderId the primary key of the current journal folder
1216            * @param groupId the group ID
1217            * @param parentFolderId the parent folder ID
1218            * @param status the status
1219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1220            * @return the previous, current, and next journal folder
1221            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1222            */
1223            public JournalFolder[] filterFindByG_P_S_PrevAndNext(long folderId,
1224                    long groupId, long parentFolderId, int status,
1225                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1226                    throws com.liferay.portlet.journal.NoSuchFolderException;
1227    
1228            /**
1229            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63; from the database.
1230            *
1231            * @param groupId the group ID
1232            * @param parentFolderId the parent folder ID
1233            * @param status the status
1234            */
1235            public void removeByG_P_S(long groupId, long parentFolderId, int status);
1236    
1237            /**
1238            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1239            *
1240            * @param groupId the group ID
1241            * @param parentFolderId the parent folder ID
1242            * @param status the status
1243            * @return the number of matching journal folders
1244            */
1245            public int countByG_P_S(long groupId, long parentFolderId, int status);
1246    
1247            /**
1248            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1249            *
1250            * @param groupId the group ID
1251            * @param parentFolderId the parent folder ID
1252            * @param status the status
1253            * @return the number of matching journal folders that the user has permission to view
1254            */
1255            public int filterCountByG_P_S(long groupId, long parentFolderId, int status);
1256    
1257            /**
1258            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1259            *
1260            * @param groupId the group ID
1261            * @param parentFolderId the parent folder ID
1262            * @param status the status
1263            * @return the matching journal folders
1264            */
1265            public java.util.List<JournalFolder> findByG_P_NotS(long groupId,
1266                    long parentFolderId, int status);
1267    
1268            /**
1269            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1270            *
1271            * <p>
1272            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1273            * </p>
1274            *
1275            * @param groupId the group ID
1276            * @param parentFolderId the parent folder ID
1277            * @param status the status
1278            * @param start the lower bound of the range of journal folders
1279            * @param end the upper bound of the range of journal folders (not inclusive)
1280            * @return the range of matching journal folders
1281            */
1282            public java.util.List<JournalFolder> findByG_P_NotS(long groupId,
1283                    long parentFolderId, int status, int start, int end);
1284    
1285            /**
1286            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1287            *
1288            * <p>
1289            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1290            * </p>
1291            *
1292            * @param groupId the group ID
1293            * @param parentFolderId the parent folder ID
1294            * @param status the status
1295            * @param start the lower bound of the range of journal folders
1296            * @param end the upper bound of the range of journal folders (not inclusive)
1297            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1298            * @return the ordered range of matching journal folders
1299            */
1300            public java.util.List<JournalFolder> findByG_P_NotS(long groupId,
1301                    long parentFolderId, int status, int start, int end,
1302                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1303    
1304            /**
1305            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1306            *
1307            * @param groupId the group ID
1308            * @param parentFolderId the parent folder ID
1309            * @param status the status
1310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1311            * @return the first matching journal folder
1312            * @throws NoSuchFolderException if a matching journal folder could not be found
1313            */
1314            public JournalFolder findByG_P_NotS_First(long groupId,
1315                    long parentFolderId, int status,
1316                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1317                    throws com.liferay.portlet.journal.NoSuchFolderException;
1318    
1319            /**
1320            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1321            *
1322            * @param groupId the group ID
1323            * @param parentFolderId the parent folder ID
1324            * @param status the status
1325            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1326            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1327            */
1328            public JournalFolder fetchByG_P_NotS_First(long groupId,
1329                    long parentFolderId, int status,
1330                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1331    
1332            /**
1333            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1334            *
1335            * @param groupId the group ID
1336            * @param parentFolderId the parent folder ID
1337            * @param status the status
1338            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1339            * @return the last matching journal folder
1340            * @throws NoSuchFolderException if a matching journal folder could not be found
1341            */
1342            public JournalFolder findByG_P_NotS_Last(long groupId, long parentFolderId,
1343                    int status,
1344                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1345                    throws com.liferay.portlet.journal.NoSuchFolderException;
1346    
1347            /**
1348            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1349            *
1350            * @param groupId the group ID
1351            * @param parentFolderId the parent folder ID
1352            * @param status the status
1353            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1354            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1355            */
1356            public JournalFolder fetchByG_P_NotS_Last(long groupId,
1357                    long parentFolderId, int status,
1358                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1359    
1360            /**
1361            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1362            *
1363            * @param folderId the primary key of the current journal folder
1364            * @param groupId the group ID
1365            * @param parentFolderId the parent folder ID
1366            * @param status the status
1367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1368            * @return the previous, current, and next journal folder
1369            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1370            */
1371            public JournalFolder[] findByG_P_NotS_PrevAndNext(long folderId,
1372                    long groupId, long parentFolderId, int status,
1373                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1374                    throws com.liferay.portlet.journal.NoSuchFolderException;
1375    
1376            /**
1377            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1378            *
1379            * @param groupId the group ID
1380            * @param parentFolderId the parent folder ID
1381            * @param status the status
1382            * @return the matching journal folders that the user has permission to view
1383            */
1384            public java.util.List<JournalFolder> filterFindByG_P_NotS(long groupId,
1385                    long parentFolderId, int status);
1386    
1387            /**
1388            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1389            *
1390            * <p>
1391            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1392            * </p>
1393            *
1394            * @param groupId the group ID
1395            * @param parentFolderId the parent folder ID
1396            * @param status the status
1397            * @param start the lower bound of the range of journal folders
1398            * @param end the upper bound of the range of journal folders (not inclusive)
1399            * @return the range of matching journal folders that the user has permission to view
1400            */
1401            public java.util.List<JournalFolder> filterFindByG_P_NotS(long groupId,
1402                    long parentFolderId, int status, int start, int end);
1403    
1404            /**
1405            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1406            *
1407            * <p>
1408            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1409            * </p>
1410            *
1411            * @param groupId the group ID
1412            * @param parentFolderId the parent folder ID
1413            * @param status the status
1414            * @param start the lower bound of the range of journal folders
1415            * @param end the upper bound of the range of journal folders (not inclusive)
1416            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1417            * @return the ordered range of matching journal folders that the user has permission to view
1418            */
1419            public java.util.List<JournalFolder> filterFindByG_P_NotS(long groupId,
1420                    long parentFolderId, int status, int start, int end,
1421                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1422    
1423            /**
1424            * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1425            *
1426            * @param folderId the primary key of the current journal folder
1427            * @param groupId the group ID
1428            * @param parentFolderId the parent folder ID
1429            * @param status the status
1430            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1431            * @return the previous, current, and next journal folder
1432            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1433            */
1434            public JournalFolder[] filterFindByG_P_NotS_PrevAndNext(long folderId,
1435                    long groupId, long parentFolderId, int status,
1436                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1437                    throws com.liferay.portlet.journal.NoSuchFolderException;
1438    
1439            /**
1440            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1441            *
1442            * @param groupId the group ID
1443            * @param parentFolderId the parent folder ID
1444            * @param status the status
1445            */
1446            public void removeByG_P_NotS(long groupId, long parentFolderId, int status);
1447    
1448            /**
1449            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1450            *
1451            * @param groupId the group ID
1452            * @param parentFolderId the parent folder ID
1453            * @param status the status
1454            * @return the number of matching journal folders
1455            */
1456            public int countByG_P_NotS(long groupId, long parentFolderId, int status);
1457    
1458            /**
1459            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1460            *
1461            * @param groupId the group ID
1462            * @param parentFolderId the parent folder ID
1463            * @param status the status
1464            * @return the number of matching journal folders that the user has permission to view
1465            */
1466            public int filterCountByG_P_NotS(long groupId, long parentFolderId,
1467                    int status);
1468    
1469            /**
1470            * Returns all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1471            *
1472            * @param folderId the folder ID
1473            * @param companyId the company ID
1474            * @param parentFolderId the parent folder ID
1475            * @param status the status
1476            * @return the matching journal folders
1477            */
1478            public java.util.List<JournalFolder> findByF_C_P_NotS(long folderId,
1479                    long companyId, long parentFolderId, int status);
1480    
1481            /**
1482            * Returns a range of all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1483            *
1484            * <p>
1485            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1486            * </p>
1487            *
1488            * @param folderId the folder ID
1489            * @param companyId the company ID
1490            * @param parentFolderId the parent folder ID
1491            * @param status the status
1492            * @param start the lower bound of the range of journal folders
1493            * @param end the upper bound of the range of journal folders (not inclusive)
1494            * @return the range of matching journal folders
1495            */
1496            public java.util.List<JournalFolder> findByF_C_P_NotS(long folderId,
1497                    long companyId, long parentFolderId, int status, int start, int end);
1498    
1499            /**
1500            * Returns an ordered range of all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1501            *
1502            * <p>
1503            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1504            * </p>
1505            *
1506            * @param folderId the folder ID
1507            * @param companyId the company ID
1508            * @param parentFolderId the parent folder ID
1509            * @param status the status
1510            * @param start the lower bound of the range of journal folders
1511            * @param end the upper bound of the range of journal folders (not inclusive)
1512            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1513            * @return the ordered range of matching journal folders
1514            */
1515            public java.util.List<JournalFolder> findByF_C_P_NotS(long folderId,
1516                    long companyId, long parentFolderId, int status, int start, int end,
1517                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1518    
1519            /**
1520            * Returns the first journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1521            *
1522            * @param folderId the folder ID
1523            * @param companyId the company ID
1524            * @param parentFolderId the parent folder ID
1525            * @param status the status
1526            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1527            * @return the first matching journal folder
1528            * @throws NoSuchFolderException if a matching journal folder could not be found
1529            */
1530            public JournalFolder findByF_C_P_NotS_First(long folderId, long companyId,
1531                    long parentFolderId, int status,
1532                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1533                    throws com.liferay.portlet.journal.NoSuchFolderException;
1534    
1535            /**
1536            * Returns the first journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1537            *
1538            * @param folderId the folder ID
1539            * @param companyId the company ID
1540            * @param parentFolderId the parent folder ID
1541            * @param status the status
1542            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1543            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1544            */
1545            public JournalFolder fetchByF_C_P_NotS_First(long folderId, long companyId,
1546                    long parentFolderId, int status,
1547                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1548    
1549            /**
1550            * Returns the last journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1551            *
1552            * @param folderId the folder ID
1553            * @param companyId the company ID
1554            * @param parentFolderId the parent folder ID
1555            * @param status the status
1556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1557            * @return the last matching journal folder
1558            * @throws NoSuchFolderException if a matching journal folder could not be found
1559            */
1560            public JournalFolder findByF_C_P_NotS_Last(long folderId, long companyId,
1561                    long parentFolderId, int status,
1562                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator)
1563                    throws com.liferay.portlet.journal.NoSuchFolderException;
1564    
1565            /**
1566            * Returns the last journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1567            *
1568            * @param folderId the folder ID
1569            * @param companyId the company ID
1570            * @param parentFolderId the parent folder ID
1571            * @param status the status
1572            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1573            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1574            */
1575            public JournalFolder fetchByF_C_P_NotS_Last(long folderId, long companyId,
1576                    long parentFolderId, int status,
1577                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1578    
1579            /**
1580            * Removes all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1581            *
1582            * @param folderId the folder ID
1583            * @param companyId the company ID
1584            * @param parentFolderId the parent folder ID
1585            * @param status the status
1586            */
1587            public void removeByF_C_P_NotS(long folderId, long companyId,
1588                    long parentFolderId, int status);
1589    
1590            /**
1591            * Returns the number of journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1592            *
1593            * @param folderId the folder ID
1594            * @param companyId the company ID
1595            * @param parentFolderId the parent folder ID
1596            * @param status the status
1597            * @return the number of matching journal folders
1598            */
1599            public int countByF_C_P_NotS(long folderId, long companyId,
1600                    long parentFolderId, int status);
1601    
1602            /**
1603            * Caches the journal folder in the entity cache if it is enabled.
1604            *
1605            * @param journalFolder the journal folder
1606            */
1607            public void cacheResult(JournalFolder journalFolder);
1608    
1609            /**
1610            * Caches the journal folders in the entity cache if it is enabled.
1611            *
1612            * @param journalFolders the journal folders
1613            */
1614            public void cacheResult(java.util.List<JournalFolder> journalFolders);
1615    
1616            /**
1617            * Creates a new journal folder with the primary key. Does not add the journal folder to the database.
1618            *
1619            * @param folderId the primary key for the new journal folder
1620            * @return the new journal folder
1621            */
1622            public JournalFolder create(long folderId);
1623    
1624            /**
1625            * Removes the journal folder with the primary key from the database. Also notifies the appropriate model listeners.
1626            *
1627            * @param folderId the primary key of the journal folder
1628            * @return the journal folder that was removed
1629            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1630            */
1631            public JournalFolder remove(long folderId)
1632                    throws com.liferay.portlet.journal.NoSuchFolderException;
1633    
1634            public JournalFolder updateImpl(JournalFolder journalFolder);
1635    
1636            /**
1637            * Returns the journal folder with the primary key or throws a {@link NoSuchFolderException} if it could not be found.
1638            *
1639            * @param folderId the primary key of the journal folder
1640            * @return the journal folder
1641            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1642            */
1643            public JournalFolder findByPrimaryKey(long folderId)
1644                    throws com.liferay.portlet.journal.NoSuchFolderException;
1645    
1646            /**
1647            * Returns the journal folder with the primary key or returns <code>null</code> if it could not be found.
1648            *
1649            * @param folderId the primary key of the journal folder
1650            * @return the journal folder, or <code>null</code> if a journal folder with the primary key could not be found
1651            */
1652            public JournalFolder fetchByPrimaryKey(long folderId);
1653    
1654            @Override
1655            public java.util.Map<java.io.Serializable, JournalFolder> fetchByPrimaryKeys(
1656                    java.util.Set<java.io.Serializable> primaryKeys);
1657    
1658            /**
1659            * Returns all the journal folders.
1660            *
1661            * @return the journal folders
1662            */
1663            public java.util.List<JournalFolder> findAll();
1664    
1665            /**
1666            * Returns a range of all the journal folders.
1667            *
1668            * <p>
1669            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1670            * </p>
1671            *
1672            * @param start the lower bound of the range of journal folders
1673            * @param end the upper bound of the range of journal folders (not inclusive)
1674            * @return the range of journal folders
1675            */
1676            public java.util.List<JournalFolder> findAll(int start, int end);
1677    
1678            /**
1679            * Returns an ordered range of all the journal folders.
1680            *
1681            * <p>
1682            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1683            * </p>
1684            *
1685            * @param start the lower bound of the range of journal folders
1686            * @param end the upper bound of the range of journal folders (not inclusive)
1687            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1688            * @return the ordered range of journal folders
1689            */
1690            public java.util.List<JournalFolder> findAll(int start, int end,
1691                    com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator);
1692    
1693            /**
1694            * Removes all the journal folders from the database.
1695            */
1696            public void removeAll();
1697    
1698            /**
1699            * Returns the number of journal folders.
1700            *
1701            * @return the number of journal folders
1702            */
1703            public int countAll();
1704    }