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.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.journal.model.JournalFolder;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the journal folder service. This utility wraps {@link com.liferay.portlet.journal.service.persistence.impl.JournalFolderPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see JournalFolderPersistence
038     * @see com.liferay.portlet.journal.service.persistence.impl.JournalFolderPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class JournalFolderUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(JournalFolder journalFolder) {
060                    getPersistence().clearCache(journalFolder);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<JournalFolder> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<JournalFolder> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalFolder> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<JournalFolder> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static JournalFolder update(JournalFolder journalFolder) {
101                    return getPersistence().update(journalFolder);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static JournalFolder update(JournalFolder journalFolder,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(journalFolder, serviceContext);
110            }
111    
112            /**
113            * Returns all the journal folders where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching journal folders
117            */
118            public static List<JournalFolder> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the journal folders where uuid = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of journal folders
131            * @param end the upper bound of the range of journal folders (not inclusive)
132            * @return the range of matching journal folders
133            */
134            public static List<JournalFolder> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the journal folders where uuid = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of journal folders
148            * @param end the upper bound of the range of journal folders (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching journal folders
151            */
152            public static List<JournalFolder> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<JournalFolder> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first journal folder in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching journal folder
163            * @throws NoSuchFolderException if a matching journal folder could not be found
164            */
165            public static JournalFolder findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<JournalFolder> orderByComparator)
167                    throws com.liferay.portlet.journal.NoSuchFolderException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first journal folder in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
177            */
178            public static JournalFolder fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<JournalFolder> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last journal folder in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching journal folder
189            * @throws NoSuchFolderException if a matching journal folder could not be found
190            */
191            public static JournalFolder findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<JournalFolder> orderByComparator)
193                    throws com.liferay.portlet.journal.NoSuchFolderException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last journal folder in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
203            */
204            public static JournalFolder fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<JournalFolder> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the journal folders before and after the current journal folder in the ordered set where uuid = &#63;.
211            *
212            * @param folderId the primary key of the current journal folder
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next journal folder
216            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
217            */
218            public static JournalFolder[] findByUuid_PrevAndNext(long folderId,
219                    java.lang.String uuid,
220                    OrderByComparator<JournalFolder> orderByComparator)
221                    throws com.liferay.portlet.journal.NoSuchFolderException {
222                    return getPersistence()
223                                       .findByUuid_PrevAndNext(folderId, uuid, orderByComparator);
224            }
225    
226            /**
227            * Removes all the journal folders where uuid = &#63; from the database.
228            *
229            * @param uuid the uuid
230            */
231            public static void removeByUuid(java.lang.String uuid) {
232                    getPersistence().removeByUuid(uuid);
233            }
234    
235            /**
236            * Returns the number of journal folders where uuid = &#63;.
237            *
238            * @param uuid the uuid
239            * @return the number of matching journal folders
240            */
241            public static int countByUuid(java.lang.String uuid) {
242                    return getPersistence().countByUuid(uuid);
243            }
244    
245            /**
246            * Returns the journal folder where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
247            *
248            * @param uuid the uuid
249            * @param groupId the group ID
250            * @return the matching journal folder
251            * @throws NoSuchFolderException if a matching journal folder could not be found
252            */
253            public static JournalFolder findByUUID_G(java.lang.String uuid, long groupId)
254                    throws com.liferay.portlet.journal.NoSuchFolderException {
255                    return getPersistence().findByUUID_G(uuid, groupId);
256            }
257    
258            /**
259            * 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.
260            *
261            * @param uuid the uuid
262            * @param groupId the group ID
263            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
264            */
265            public static JournalFolder fetchByUUID_G(java.lang.String uuid,
266                    long groupId) {
267                    return getPersistence().fetchByUUID_G(uuid, groupId);
268            }
269    
270            /**
271            * 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.
272            *
273            * @param uuid the uuid
274            * @param groupId the group ID
275            * @param retrieveFromCache whether to use the finder cache
276            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
277            */
278            public static JournalFolder fetchByUUID_G(java.lang.String uuid,
279                    long groupId, boolean retrieveFromCache) {
280                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
281            }
282    
283            /**
284            * Removes the journal folder where uuid = &#63; and groupId = &#63; from the database.
285            *
286            * @param uuid the uuid
287            * @param groupId the group ID
288            * @return the journal folder that was removed
289            */
290            public static JournalFolder removeByUUID_G(java.lang.String uuid,
291                    long groupId) throws com.liferay.portlet.journal.NoSuchFolderException {
292                    return getPersistence().removeByUUID_G(uuid, groupId);
293            }
294    
295            /**
296            * Returns the number of journal folders where uuid = &#63; and groupId = &#63;.
297            *
298            * @param uuid the uuid
299            * @param groupId the group ID
300            * @return the number of matching journal folders
301            */
302            public static int countByUUID_G(java.lang.String uuid, long groupId) {
303                    return getPersistence().countByUUID_G(uuid, groupId);
304            }
305    
306            /**
307            * Returns all the journal folders where uuid = &#63; and companyId = &#63;.
308            *
309            * @param uuid the uuid
310            * @param companyId the company ID
311            * @return the matching journal folders
312            */
313            public static List<JournalFolder> findByUuid_C(java.lang.String uuid,
314                    long companyId) {
315                    return getPersistence().findByUuid_C(uuid, companyId);
316            }
317    
318            /**
319            * Returns a range of all the journal folders where uuid = &#63; and companyId = &#63;.
320            *
321            * <p>
322            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
323            * </p>
324            *
325            * @param uuid the uuid
326            * @param companyId the company ID
327            * @param start the lower bound of the range of journal folders
328            * @param end the upper bound of the range of journal folders (not inclusive)
329            * @return the range of matching journal folders
330            */
331            public static List<JournalFolder> findByUuid_C(java.lang.String uuid,
332                    long companyId, int start, int end) {
333                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
334            }
335    
336            /**
337            * Returns an ordered range of all the journal folders where uuid = &#63; and companyId = &#63;.
338            *
339            * <p>
340            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
341            * </p>
342            *
343            * @param uuid the uuid
344            * @param companyId the company ID
345            * @param start the lower bound of the range of journal folders
346            * @param end the upper bound of the range of journal folders (not inclusive)
347            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
348            * @return the ordered range of matching journal folders
349            */
350            public static List<JournalFolder> findByUuid_C(java.lang.String uuid,
351                    long companyId, int start, int end,
352                    OrderByComparator<JournalFolder> orderByComparator) {
353                    return getPersistence()
354                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
355            }
356    
357            /**
358            * Returns the first journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
363            * @return the first matching journal folder
364            * @throws NoSuchFolderException if a matching journal folder could not be found
365            */
366            public static JournalFolder findByUuid_C_First(java.lang.String uuid,
367                    long companyId, OrderByComparator<JournalFolder> orderByComparator)
368                    throws com.liferay.portlet.journal.NoSuchFolderException {
369                    return getPersistence()
370                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
371            }
372    
373            /**
374            * Returns the first journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
375            *
376            * @param uuid the uuid
377            * @param companyId the company ID
378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
379            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
380            */
381            public static JournalFolder fetchByUuid_C_First(java.lang.String uuid,
382                    long companyId, OrderByComparator<JournalFolder> orderByComparator) {
383                    return getPersistence()
384                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
385            }
386    
387            /**
388            * Returns the last journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
389            *
390            * @param uuid the uuid
391            * @param companyId the company ID
392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
393            * @return the last matching journal folder
394            * @throws NoSuchFolderException if a matching journal folder could not be found
395            */
396            public static JournalFolder findByUuid_C_Last(java.lang.String uuid,
397                    long companyId, OrderByComparator<JournalFolder> orderByComparator)
398                    throws com.liferay.portlet.journal.NoSuchFolderException {
399                    return getPersistence()
400                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
401            }
402    
403            /**
404            * Returns the last journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
405            *
406            * @param uuid the uuid
407            * @param companyId the company ID
408            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
409            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
410            */
411            public static JournalFolder fetchByUuid_C_Last(java.lang.String uuid,
412                    long companyId, OrderByComparator<JournalFolder> orderByComparator) {
413                    return getPersistence()
414                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
415            }
416    
417            /**
418            * Returns the journal folders before and after the current journal folder in the ordered set where uuid = &#63; and companyId = &#63;.
419            *
420            * @param folderId the primary key of the current journal folder
421            * @param uuid the uuid
422            * @param companyId the company 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 static JournalFolder[] findByUuid_C_PrevAndNext(long folderId,
428                    java.lang.String uuid, long companyId,
429                    OrderByComparator<JournalFolder> orderByComparator)
430                    throws com.liferay.portlet.journal.NoSuchFolderException {
431                    return getPersistence()
432                                       .findByUuid_C_PrevAndNext(folderId, uuid, companyId,
433                            orderByComparator);
434            }
435    
436            /**
437            * Removes all the journal folders where uuid = &#63; and companyId = &#63; from the database.
438            *
439            * @param uuid the uuid
440            * @param companyId the company ID
441            */
442            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
443                    getPersistence().removeByUuid_C(uuid, companyId);
444            }
445    
446            /**
447            * Returns the number of journal folders where uuid = &#63; and companyId = &#63;.
448            *
449            * @param uuid the uuid
450            * @param companyId the company ID
451            * @return the number of matching journal folders
452            */
453            public static int countByUuid_C(java.lang.String uuid, long companyId) {
454                    return getPersistence().countByUuid_C(uuid, companyId);
455            }
456    
457            /**
458            * Returns all the journal folders where groupId = &#63;.
459            *
460            * @param groupId the group ID
461            * @return the matching journal folders
462            */
463            public static List<JournalFolder> findByGroupId(long groupId) {
464                    return getPersistence().findByGroupId(groupId);
465            }
466    
467            /**
468            * Returns a range of all the journal folders where groupId = &#63;.
469            *
470            * <p>
471            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
472            * </p>
473            *
474            * @param groupId the group ID
475            * @param start the lower bound of the range of journal folders
476            * @param end the upper bound of the range of journal folders (not inclusive)
477            * @return the range of matching journal folders
478            */
479            public static List<JournalFolder> findByGroupId(long groupId, int start,
480                    int end) {
481                    return getPersistence().findByGroupId(groupId, start, end);
482            }
483    
484            /**
485            * Returns an ordered range of all the journal folders where groupId = &#63;.
486            *
487            * <p>
488            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
489            * </p>
490            *
491            * @param groupId the group ID
492            * @param start the lower bound of the range of journal folders
493            * @param end the upper bound of the range of journal folders (not inclusive)
494            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
495            * @return the ordered range of matching journal folders
496            */
497            public static List<JournalFolder> findByGroupId(long groupId, int start,
498                    int end, OrderByComparator<JournalFolder> orderByComparator) {
499                    return getPersistence()
500                                       .findByGroupId(groupId, start, end, orderByComparator);
501            }
502    
503            /**
504            * Returns the first journal folder in the ordered set where groupId = &#63;.
505            *
506            * @param groupId the group ID
507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
508            * @return the first matching journal folder
509            * @throws NoSuchFolderException if a matching journal folder could not be found
510            */
511            public static JournalFolder findByGroupId_First(long groupId,
512                    OrderByComparator<JournalFolder> orderByComparator)
513                    throws com.liferay.portlet.journal.NoSuchFolderException {
514                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
515            }
516    
517            /**
518            * Returns the first journal folder in the ordered set where groupId = &#63;.
519            *
520            * @param groupId the group ID
521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
522            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
523            */
524            public static JournalFolder fetchByGroupId_First(long groupId,
525                    OrderByComparator<JournalFolder> orderByComparator) {
526                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
527            }
528    
529            /**
530            * Returns the last journal folder in the ordered set where groupId = &#63;.
531            *
532            * @param groupId the group ID
533            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
534            * @return the last matching journal folder
535            * @throws NoSuchFolderException if a matching journal folder could not be found
536            */
537            public static JournalFolder findByGroupId_Last(long groupId,
538                    OrderByComparator<JournalFolder> orderByComparator)
539                    throws com.liferay.portlet.journal.NoSuchFolderException {
540                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
541            }
542    
543            /**
544            * Returns the last journal folder in the ordered set where groupId = &#63;.
545            *
546            * @param groupId the group ID
547            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
548            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
549            */
550            public static JournalFolder fetchByGroupId_Last(long groupId,
551                    OrderByComparator<JournalFolder> orderByComparator) {
552                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
553            }
554    
555            /**
556            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63;.
557            *
558            * @param folderId the primary key of the current journal folder
559            * @param groupId the group ID
560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
561            * @return the previous, current, and next journal folder
562            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
563            */
564            public static JournalFolder[] findByGroupId_PrevAndNext(long folderId,
565                    long groupId, OrderByComparator<JournalFolder> orderByComparator)
566                    throws com.liferay.portlet.journal.NoSuchFolderException {
567                    return getPersistence()
568                                       .findByGroupId_PrevAndNext(folderId, groupId,
569                            orderByComparator);
570            }
571    
572            /**
573            * Returns all the journal folders that the user has permission to view where groupId = &#63;.
574            *
575            * @param groupId the group ID
576            * @return the matching journal folders that the user has permission to view
577            */
578            public static List<JournalFolder> filterFindByGroupId(long groupId) {
579                    return getPersistence().filterFindByGroupId(groupId);
580            }
581    
582            /**
583            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63;.
584            *
585            * <p>
586            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
587            * </p>
588            *
589            * @param groupId the group ID
590            * @param start the lower bound of the range of journal folders
591            * @param end the upper bound of the range of journal folders (not inclusive)
592            * @return the range of matching journal folders that the user has permission to view
593            */
594            public static List<JournalFolder> filterFindByGroupId(long groupId,
595                    int start, int end) {
596                    return getPersistence().filterFindByGroupId(groupId, start, end);
597            }
598    
599            /**
600            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63;.
601            *
602            * <p>
603            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
604            * </p>
605            *
606            * @param groupId the group ID
607            * @param start the lower bound of the range of journal folders
608            * @param end the upper bound of the range of journal folders (not inclusive)
609            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
610            * @return the ordered range of matching journal folders that the user has permission to view
611            */
612            public static List<JournalFolder> filterFindByGroupId(long groupId,
613                    int start, int end, OrderByComparator<JournalFolder> orderByComparator) {
614                    return getPersistence()
615                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
616            }
617    
618            /**
619            * 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;.
620            *
621            * @param folderId the primary key of the current journal folder
622            * @param groupId the group ID
623            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
624            * @return the previous, current, and next journal folder
625            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
626            */
627            public static JournalFolder[] filterFindByGroupId_PrevAndNext(
628                    long folderId, long groupId,
629                    OrderByComparator<JournalFolder> orderByComparator)
630                    throws com.liferay.portlet.journal.NoSuchFolderException {
631                    return getPersistence()
632                                       .filterFindByGroupId_PrevAndNext(folderId, groupId,
633                            orderByComparator);
634            }
635    
636            /**
637            * Removes all the journal folders where groupId = &#63; from the database.
638            *
639            * @param groupId the group ID
640            */
641            public static void removeByGroupId(long groupId) {
642                    getPersistence().removeByGroupId(groupId);
643            }
644    
645            /**
646            * Returns the number of journal folders where groupId = &#63;.
647            *
648            * @param groupId the group ID
649            * @return the number of matching journal folders
650            */
651            public static int countByGroupId(long groupId) {
652                    return getPersistence().countByGroupId(groupId);
653            }
654    
655            /**
656            * Returns the number of journal folders that the user has permission to view where groupId = &#63;.
657            *
658            * @param groupId the group ID
659            * @return the number of matching journal folders that the user has permission to view
660            */
661            public static int filterCountByGroupId(long groupId) {
662                    return getPersistence().filterCountByGroupId(groupId);
663            }
664    
665            /**
666            * Returns all the journal folders where companyId = &#63;.
667            *
668            * @param companyId the company ID
669            * @return the matching journal folders
670            */
671            public static List<JournalFolder> findByCompanyId(long companyId) {
672                    return getPersistence().findByCompanyId(companyId);
673            }
674    
675            /**
676            * Returns a range of all the journal folders where companyId = &#63;.
677            *
678            * <p>
679            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
680            * </p>
681            *
682            * @param companyId the company ID
683            * @param start the lower bound of the range of journal folders
684            * @param end the upper bound of the range of journal folders (not inclusive)
685            * @return the range of matching journal folders
686            */
687            public static List<JournalFolder> findByCompanyId(long companyId,
688                    int start, int end) {
689                    return getPersistence().findByCompanyId(companyId, start, end);
690            }
691    
692            /**
693            * Returns an ordered range of all the journal folders where companyId = &#63;.
694            *
695            * <p>
696            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
697            * </p>
698            *
699            * @param companyId the company ID
700            * @param start the lower bound of the range of journal folders
701            * @param end the upper bound of the range of journal folders (not inclusive)
702            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
703            * @return the ordered range of matching journal folders
704            */
705            public static List<JournalFolder> findByCompanyId(long companyId,
706                    int start, int end, OrderByComparator<JournalFolder> orderByComparator) {
707                    return getPersistence()
708                                       .findByCompanyId(companyId, start, end, orderByComparator);
709            }
710    
711            /**
712            * Returns the first journal folder in the ordered set where companyId = &#63;.
713            *
714            * @param companyId the company ID
715            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
716            * @return the first matching journal folder
717            * @throws NoSuchFolderException if a matching journal folder could not be found
718            */
719            public static JournalFolder findByCompanyId_First(long companyId,
720                    OrderByComparator<JournalFolder> orderByComparator)
721                    throws com.liferay.portlet.journal.NoSuchFolderException {
722                    return getPersistence()
723                                       .findByCompanyId_First(companyId, orderByComparator);
724            }
725    
726            /**
727            * Returns the first journal folder in the ordered set where companyId = &#63;.
728            *
729            * @param companyId the company ID
730            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
731            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
732            */
733            public static JournalFolder fetchByCompanyId_First(long companyId,
734                    OrderByComparator<JournalFolder> orderByComparator) {
735                    return getPersistence()
736                                       .fetchByCompanyId_First(companyId, orderByComparator);
737            }
738    
739            /**
740            * Returns the last journal folder in the ordered set where companyId = &#63;.
741            *
742            * @param companyId the company ID
743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
744            * @return the last matching journal folder
745            * @throws NoSuchFolderException if a matching journal folder could not be found
746            */
747            public static JournalFolder findByCompanyId_Last(long companyId,
748                    OrderByComparator<JournalFolder> orderByComparator)
749                    throws com.liferay.portlet.journal.NoSuchFolderException {
750                    return getPersistence()
751                                       .findByCompanyId_Last(companyId, orderByComparator);
752            }
753    
754            /**
755            * Returns the last journal folder in the ordered set where companyId = &#63;.
756            *
757            * @param companyId the company ID
758            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
759            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
760            */
761            public static JournalFolder fetchByCompanyId_Last(long companyId,
762                    OrderByComparator<JournalFolder> orderByComparator) {
763                    return getPersistence()
764                                       .fetchByCompanyId_Last(companyId, orderByComparator);
765            }
766    
767            /**
768            * Returns the journal folders before and after the current journal folder in the ordered set where companyId = &#63;.
769            *
770            * @param folderId the primary key of the current journal folder
771            * @param companyId the company ID
772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
773            * @return the previous, current, and next journal folder
774            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
775            */
776            public static JournalFolder[] findByCompanyId_PrevAndNext(long folderId,
777                    long companyId, OrderByComparator<JournalFolder> orderByComparator)
778                    throws com.liferay.portlet.journal.NoSuchFolderException {
779                    return getPersistence()
780                                       .findByCompanyId_PrevAndNext(folderId, companyId,
781                            orderByComparator);
782            }
783    
784            /**
785            * Removes all the journal folders where companyId = &#63; from the database.
786            *
787            * @param companyId the company ID
788            */
789            public static void removeByCompanyId(long companyId) {
790                    getPersistence().removeByCompanyId(companyId);
791            }
792    
793            /**
794            * Returns the number of journal folders where companyId = &#63;.
795            *
796            * @param companyId the company ID
797            * @return the number of matching journal folders
798            */
799            public static int countByCompanyId(long companyId) {
800                    return getPersistence().countByCompanyId(companyId);
801            }
802    
803            /**
804            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63;.
805            *
806            * @param groupId the group ID
807            * @param parentFolderId the parent folder ID
808            * @return the matching journal folders
809            */
810            public static List<JournalFolder> findByG_P(long groupId,
811                    long parentFolderId) {
812                    return getPersistence().findByG_P(groupId, parentFolderId);
813            }
814    
815            /**
816            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63;.
817            *
818            * <p>
819            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
820            * </p>
821            *
822            * @param groupId the group ID
823            * @param parentFolderId the parent folder ID
824            * @param start the lower bound of the range of journal folders
825            * @param end the upper bound of the range of journal folders (not inclusive)
826            * @return the range of matching journal folders
827            */
828            public static List<JournalFolder> findByG_P(long groupId,
829                    long parentFolderId, int start, int end) {
830                    return getPersistence().findByG_P(groupId, parentFolderId, start, end);
831            }
832    
833            /**
834            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63;.
835            *
836            * <p>
837            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
838            * </p>
839            *
840            * @param groupId the group ID
841            * @param parentFolderId the parent folder ID
842            * @param start the lower bound of the range of journal folders
843            * @param end the upper bound of the range of journal folders (not inclusive)
844            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
845            * @return the ordered range of matching journal folders
846            */
847            public static List<JournalFolder> findByG_P(long groupId,
848                    long parentFolderId, int start, int end,
849                    OrderByComparator<JournalFolder> orderByComparator) {
850                    return getPersistence()
851                                       .findByG_P(groupId, parentFolderId, start, end,
852                            orderByComparator);
853            }
854    
855            /**
856            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
857            *
858            * @param groupId the group ID
859            * @param parentFolderId the parent folder ID
860            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
861            * @return the first matching journal folder
862            * @throws NoSuchFolderException if a matching journal folder could not be found
863            */
864            public static JournalFolder findByG_P_First(long groupId,
865                    long parentFolderId, OrderByComparator<JournalFolder> orderByComparator)
866                    throws com.liferay.portlet.journal.NoSuchFolderException {
867                    return getPersistence()
868                                       .findByG_P_First(groupId, parentFolderId, orderByComparator);
869            }
870    
871            /**
872            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
873            *
874            * @param groupId the group ID
875            * @param parentFolderId the parent folder ID
876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
877            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
878            */
879            public static JournalFolder fetchByG_P_First(long groupId,
880                    long parentFolderId, OrderByComparator<JournalFolder> orderByComparator) {
881                    return getPersistence()
882                                       .fetchByG_P_First(groupId, parentFolderId, orderByComparator);
883            }
884    
885            /**
886            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
887            *
888            * @param groupId the group ID
889            * @param parentFolderId the parent folder ID
890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
891            * @return the last matching journal folder
892            * @throws NoSuchFolderException if a matching journal folder could not be found
893            */
894            public static JournalFolder findByG_P_Last(long groupId,
895                    long parentFolderId, OrderByComparator<JournalFolder> orderByComparator)
896                    throws com.liferay.portlet.journal.NoSuchFolderException {
897                    return getPersistence()
898                                       .findByG_P_Last(groupId, parentFolderId, orderByComparator);
899            }
900    
901            /**
902            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
903            *
904            * @param groupId the group ID
905            * @param parentFolderId the parent folder ID
906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
907            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
908            */
909            public static JournalFolder fetchByG_P_Last(long groupId,
910                    long parentFolderId, OrderByComparator<JournalFolder> orderByComparator) {
911                    return getPersistence()
912                                       .fetchByG_P_Last(groupId, parentFolderId, orderByComparator);
913            }
914    
915            /**
916            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
917            *
918            * @param folderId the primary key of the current journal folder
919            * @param groupId the group ID
920            * @param parentFolderId the parent folder ID
921            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
922            * @return the previous, current, and next journal folder
923            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
924            */
925            public static JournalFolder[] findByG_P_PrevAndNext(long folderId,
926                    long groupId, long parentFolderId,
927                    OrderByComparator<JournalFolder> orderByComparator)
928                    throws com.liferay.portlet.journal.NoSuchFolderException {
929                    return getPersistence()
930                                       .findByG_P_PrevAndNext(folderId, groupId, parentFolderId,
931                            orderByComparator);
932            }
933    
934            /**
935            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
936            *
937            * @param groupId the group ID
938            * @param parentFolderId the parent folder ID
939            * @return the matching journal folders that the user has permission to view
940            */
941            public static List<JournalFolder> filterFindByG_P(long groupId,
942                    long parentFolderId) {
943                    return getPersistence().filterFindByG_P(groupId, parentFolderId);
944            }
945    
946            /**
947            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
948            *
949            * <p>
950            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
951            * </p>
952            *
953            * @param groupId the group ID
954            * @param parentFolderId the parent folder ID
955            * @param start the lower bound of the range of journal folders
956            * @param end the upper bound of the range of journal folders (not inclusive)
957            * @return the range of matching journal folders that the user has permission to view
958            */
959            public static List<JournalFolder> filterFindByG_P(long groupId,
960                    long parentFolderId, int start, int end) {
961                    return getPersistence()
962                                       .filterFindByG_P(groupId, parentFolderId, start, end);
963            }
964    
965            /**
966            * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63;.
967            *
968            * <p>
969            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
970            * </p>
971            *
972            * @param groupId the group ID
973            * @param parentFolderId the parent folder ID
974            * @param start the lower bound of the range of journal folders
975            * @param end the upper bound of the range of journal folders (not inclusive)
976            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
977            * @return the ordered range of matching journal folders that the user has permission to view
978            */
979            public static List<JournalFolder> filterFindByG_P(long groupId,
980                    long parentFolderId, int start, int end,
981                    OrderByComparator<JournalFolder> orderByComparator) {
982                    return getPersistence()
983                                       .filterFindByG_P(groupId, parentFolderId, start, end,
984                            orderByComparator);
985            }
986    
987            /**
988            * 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;.
989            *
990            * @param folderId the primary key of the current journal folder
991            * @param groupId the group ID
992            * @param parentFolderId the parent folder ID
993            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
994            * @return the previous, current, and next journal folder
995            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
996            */
997            public static JournalFolder[] filterFindByG_P_PrevAndNext(long folderId,
998                    long groupId, long parentFolderId,
999                    OrderByComparator<JournalFolder> orderByComparator)
1000                    throws com.liferay.portlet.journal.NoSuchFolderException {
1001                    return getPersistence()
1002                                       .filterFindByG_P_PrevAndNext(folderId, groupId,
1003                            parentFolderId, orderByComparator);
1004            }
1005    
1006            /**
1007            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; from the database.
1008            *
1009            * @param groupId the group ID
1010            * @param parentFolderId the parent folder ID
1011            */
1012            public static void removeByG_P(long groupId, long parentFolderId) {
1013                    getPersistence().removeByG_P(groupId, parentFolderId);
1014            }
1015    
1016            /**
1017            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63;.
1018            *
1019            * @param groupId the group ID
1020            * @param parentFolderId the parent folder ID
1021            * @return the number of matching journal folders
1022            */
1023            public static int countByG_P(long groupId, long parentFolderId) {
1024                    return getPersistence().countByG_P(groupId, parentFolderId);
1025            }
1026    
1027            /**
1028            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1029            *
1030            * @param groupId the group ID
1031            * @param parentFolderId the parent folder ID
1032            * @return the number of matching journal folders that the user has permission to view
1033            */
1034            public static int filterCountByG_P(long groupId, long parentFolderId) {
1035                    return getPersistence().filterCountByG_P(groupId, parentFolderId);
1036            }
1037    
1038            /**
1039            * Returns the journal folder where groupId = &#63; and name = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
1040            *
1041            * @param groupId the group ID
1042            * @param name the name
1043            * @return the matching journal folder
1044            * @throws NoSuchFolderException if a matching journal folder could not be found
1045            */
1046            public static JournalFolder findByG_N(long groupId, java.lang.String name)
1047                    throws com.liferay.portlet.journal.NoSuchFolderException {
1048                    return getPersistence().findByG_N(groupId, name);
1049            }
1050    
1051            /**
1052            * 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.
1053            *
1054            * @param groupId the group ID
1055            * @param name the name
1056            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1057            */
1058            public static JournalFolder fetchByG_N(long groupId, java.lang.String name) {
1059                    return getPersistence().fetchByG_N(groupId, name);
1060            }
1061    
1062            /**
1063            * 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.
1064            *
1065            * @param groupId the group ID
1066            * @param name the name
1067            * @param retrieveFromCache whether to use the finder cache
1068            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1069            */
1070            public static JournalFolder fetchByG_N(long groupId, java.lang.String name,
1071                    boolean retrieveFromCache) {
1072                    return getPersistence().fetchByG_N(groupId, name, retrieveFromCache);
1073            }
1074    
1075            /**
1076            * Removes the journal folder where groupId = &#63; and name = &#63; from the database.
1077            *
1078            * @param groupId the group ID
1079            * @param name the name
1080            * @return the journal folder that was removed
1081            */
1082            public static JournalFolder removeByG_N(long groupId, java.lang.String name)
1083                    throws com.liferay.portlet.journal.NoSuchFolderException {
1084                    return getPersistence().removeByG_N(groupId, name);
1085            }
1086    
1087            /**
1088            * Returns the number of journal folders where groupId = &#63; and name = &#63;.
1089            *
1090            * @param groupId the group ID
1091            * @param name the name
1092            * @return the number of matching journal folders
1093            */
1094            public static int countByG_N(long groupId, java.lang.String name) {
1095                    return getPersistence().countByG_N(groupId, name);
1096            }
1097    
1098            /**
1099            * Returns all the journal folders where companyId = &#63; and status &ne; &#63;.
1100            *
1101            * @param companyId the company ID
1102            * @param status the status
1103            * @return the matching journal folders
1104            */
1105            public static List<JournalFolder> findByC_NotS(long companyId, int status) {
1106                    return getPersistence().findByC_NotS(companyId, status);
1107            }
1108    
1109            /**
1110            * Returns a range of all the journal folders where companyId = &#63; and status &ne; &#63;.
1111            *
1112            * <p>
1113            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1114            * </p>
1115            *
1116            * @param companyId the company ID
1117            * @param status the status
1118            * @param start the lower bound of the range of journal folders
1119            * @param end the upper bound of the range of journal folders (not inclusive)
1120            * @return the range of matching journal folders
1121            */
1122            public static List<JournalFolder> findByC_NotS(long companyId, int status,
1123                    int start, int end) {
1124                    return getPersistence().findByC_NotS(companyId, status, start, end);
1125            }
1126    
1127            /**
1128            * Returns an ordered range of all the journal folders where companyId = &#63; and status &ne; &#63;.
1129            *
1130            * <p>
1131            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1132            * </p>
1133            *
1134            * @param companyId the company ID
1135            * @param status the status
1136            * @param start the lower bound of the range of journal folders
1137            * @param end the upper bound of the range of journal folders (not inclusive)
1138            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1139            * @return the ordered range of matching journal folders
1140            */
1141            public static List<JournalFolder> findByC_NotS(long companyId, int status,
1142                    int start, int end, OrderByComparator<JournalFolder> orderByComparator) {
1143                    return getPersistence()
1144                                       .findByC_NotS(companyId, status, start, end,
1145                            orderByComparator);
1146            }
1147    
1148            /**
1149            * Returns the first journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1150            *
1151            * @param companyId the company ID
1152            * @param status the status
1153            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1154            * @return the first matching journal folder
1155            * @throws NoSuchFolderException if a matching journal folder could not be found
1156            */
1157            public static JournalFolder findByC_NotS_First(long companyId, int status,
1158                    OrderByComparator<JournalFolder> orderByComparator)
1159                    throws com.liferay.portlet.journal.NoSuchFolderException {
1160                    return getPersistence()
1161                                       .findByC_NotS_First(companyId, status, orderByComparator);
1162            }
1163    
1164            /**
1165            * Returns the first journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1166            *
1167            * @param companyId the company ID
1168            * @param status the status
1169            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1170            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1171            */
1172            public static JournalFolder fetchByC_NotS_First(long companyId, int status,
1173                    OrderByComparator<JournalFolder> orderByComparator) {
1174                    return getPersistence()
1175                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1176            }
1177    
1178            /**
1179            * Returns the last journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1180            *
1181            * @param companyId the company ID
1182            * @param status the status
1183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1184            * @return the last matching journal folder
1185            * @throws NoSuchFolderException if a matching journal folder could not be found
1186            */
1187            public static JournalFolder findByC_NotS_Last(long companyId, int status,
1188                    OrderByComparator<JournalFolder> orderByComparator)
1189                    throws com.liferay.portlet.journal.NoSuchFolderException {
1190                    return getPersistence()
1191                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1192            }
1193    
1194            /**
1195            * Returns the last journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1196            *
1197            * @param companyId the company ID
1198            * @param status the status
1199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1200            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1201            */
1202            public static JournalFolder fetchByC_NotS_Last(long companyId, int status,
1203                    OrderByComparator<JournalFolder> orderByComparator) {
1204                    return getPersistence()
1205                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1206            }
1207    
1208            /**
1209            * Returns the journal folders before and after the current journal folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1210            *
1211            * @param folderId the primary key of the current journal folder
1212            * @param companyId the company ID
1213            * @param status the status
1214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1215            * @return the previous, current, and next journal folder
1216            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1217            */
1218            public static JournalFolder[] findByC_NotS_PrevAndNext(long folderId,
1219                    long companyId, int status,
1220                    OrderByComparator<JournalFolder> orderByComparator)
1221                    throws com.liferay.portlet.journal.NoSuchFolderException {
1222                    return getPersistence()
1223                                       .findByC_NotS_PrevAndNext(folderId, companyId, status,
1224                            orderByComparator);
1225            }
1226    
1227            /**
1228            * Removes all the journal folders where companyId = &#63; and status &ne; &#63; from the database.
1229            *
1230            * @param companyId the company ID
1231            * @param status the status
1232            */
1233            public static void removeByC_NotS(long companyId, int status) {
1234                    getPersistence().removeByC_NotS(companyId, status);
1235            }
1236    
1237            /**
1238            * Returns the number of journal folders where companyId = &#63; and status &ne; &#63;.
1239            *
1240            * @param companyId the company ID
1241            * @param status the status
1242            * @return the number of matching journal folders
1243            */
1244            public static int countByC_NotS(long companyId, int status) {
1245                    return getPersistence().countByC_NotS(companyId, status);
1246            }
1247    
1248            /**
1249            * Returns the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
1250            *
1251            * @param groupId the group ID
1252            * @param parentFolderId the parent folder ID
1253            * @param name the name
1254            * @return the matching journal folder
1255            * @throws NoSuchFolderException if a matching journal folder could not be found
1256            */
1257            public static JournalFolder findByG_P_N(long groupId, long parentFolderId,
1258                    java.lang.String name)
1259                    throws com.liferay.portlet.journal.NoSuchFolderException {
1260                    return getPersistence().findByG_P_N(groupId, parentFolderId, name);
1261            }
1262    
1263            /**
1264            * 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.
1265            *
1266            * @param groupId the group ID
1267            * @param parentFolderId the parent folder ID
1268            * @param name the name
1269            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1270            */
1271            public static JournalFolder fetchByG_P_N(long groupId, long parentFolderId,
1272                    java.lang.String name) {
1273                    return getPersistence().fetchByG_P_N(groupId, parentFolderId, name);
1274            }
1275    
1276            /**
1277            * 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.
1278            *
1279            * @param groupId the group ID
1280            * @param parentFolderId the parent folder ID
1281            * @param name the name
1282            * @param retrieveFromCache whether to use the finder cache
1283            * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found
1284            */
1285            public static JournalFolder fetchByG_P_N(long groupId, long parentFolderId,
1286                    java.lang.String name, boolean retrieveFromCache) {
1287                    return getPersistence()
1288                                       .fetchByG_P_N(groupId, parentFolderId, name,
1289                            retrieveFromCache);
1290            }
1291    
1292            /**
1293            * Removes the journal folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; from the database.
1294            *
1295            * @param groupId the group ID
1296            * @param parentFolderId the parent folder ID
1297            * @param name the name
1298            * @return the journal folder that was removed
1299            */
1300            public static JournalFolder removeByG_P_N(long groupId,
1301                    long parentFolderId, java.lang.String name)
1302                    throws com.liferay.portlet.journal.NoSuchFolderException {
1303                    return getPersistence().removeByG_P_N(groupId, parentFolderId, name);
1304            }
1305    
1306            /**
1307            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and name = &#63;.
1308            *
1309            * @param groupId the group ID
1310            * @param parentFolderId the parent folder ID
1311            * @param name the name
1312            * @return the number of matching journal folders
1313            */
1314            public static int countByG_P_N(long groupId, long parentFolderId,
1315                    java.lang.String name) {
1316                    return getPersistence().countByG_P_N(groupId, parentFolderId, name);
1317            }
1318    
1319            /**
1320            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1321            *
1322            * @param groupId the group ID
1323            * @param parentFolderId the parent folder ID
1324            * @param status the status
1325            * @return the matching journal folders
1326            */
1327            public static List<JournalFolder> findByG_P_S(long groupId,
1328                    long parentFolderId, int status) {
1329                    return getPersistence().findByG_P_S(groupId, parentFolderId, status);
1330            }
1331    
1332            /**
1333            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1334            *
1335            * <p>
1336            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1337            * </p>
1338            *
1339            * @param groupId the group ID
1340            * @param parentFolderId the parent folder ID
1341            * @param status the status
1342            * @param start the lower bound of the range of journal folders
1343            * @param end the upper bound of the range of journal folders (not inclusive)
1344            * @return the range of matching journal folders
1345            */
1346            public static List<JournalFolder> findByG_P_S(long groupId,
1347                    long parentFolderId, int status, int start, int end) {
1348                    return getPersistence()
1349                                       .findByG_P_S(groupId, parentFolderId, status, start, end);
1350            }
1351    
1352            /**
1353            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1354            *
1355            * <p>
1356            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1357            * </p>
1358            *
1359            * @param groupId the group ID
1360            * @param parentFolderId the parent folder ID
1361            * @param status the status
1362            * @param start the lower bound of the range of journal folders
1363            * @param end the upper bound of the range of journal folders (not inclusive)
1364            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1365            * @return the ordered range of matching journal folders
1366            */
1367            public static List<JournalFolder> findByG_P_S(long groupId,
1368                    long parentFolderId, int status, int start, int end,
1369                    OrderByComparator<JournalFolder> orderByComparator) {
1370                    return getPersistence()
1371                                       .findByG_P_S(groupId, parentFolderId, status, start, end,
1372                            orderByComparator);
1373            }
1374    
1375            /**
1376            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1377            *
1378            * @param groupId the group ID
1379            * @param parentFolderId the parent folder ID
1380            * @param status the status
1381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1382            * @return the first matching journal folder
1383            * @throws NoSuchFolderException if a matching journal folder could not be found
1384            */
1385            public static JournalFolder findByG_P_S_First(long groupId,
1386                    long parentFolderId, int status,
1387                    OrderByComparator<JournalFolder> orderByComparator)
1388                    throws com.liferay.portlet.journal.NoSuchFolderException {
1389                    return getPersistence()
1390                                       .findByG_P_S_First(groupId, parentFolderId, status,
1391                            orderByComparator);
1392            }
1393    
1394            /**
1395            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1396            *
1397            * @param groupId the group ID
1398            * @param parentFolderId the parent folder ID
1399            * @param status the status
1400            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1401            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1402            */
1403            public static JournalFolder fetchByG_P_S_First(long groupId,
1404                    long parentFolderId, int status,
1405                    OrderByComparator<JournalFolder> orderByComparator) {
1406                    return getPersistence()
1407                                       .fetchByG_P_S_First(groupId, parentFolderId, status,
1408                            orderByComparator);
1409            }
1410    
1411            /**
1412            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1413            *
1414            * @param groupId the group ID
1415            * @param parentFolderId the parent folder ID
1416            * @param status the status
1417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1418            * @return the last matching journal folder
1419            * @throws NoSuchFolderException if a matching journal folder could not be found
1420            */
1421            public static JournalFolder findByG_P_S_Last(long groupId,
1422                    long parentFolderId, int status,
1423                    OrderByComparator<JournalFolder> orderByComparator)
1424                    throws com.liferay.portlet.journal.NoSuchFolderException {
1425                    return getPersistence()
1426                                       .findByG_P_S_Last(groupId, parentFolderId, status,
1427                            orderByComparator);
1428            }
1429    
1430            /**
1431            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1432            *
1433            * @param groupId the group ID
1434            * @param parentFolderId the parent folder ID
1435            * @param status the status
1436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1437            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1438            */
1439            public static JournalFolder fetchByG_P_S_Last(long groupId,
1440                    long parentFolderId, int status,
1441                    OrderByComparator<JournalFolder> orderByComparator) {
1442                    return getPersistence()
1443                                       .fetchByG_P_S_Last(groupId, parentFolderId, status,
1444                            orderByComparator);
1445            }
1446    
1447            /**
1448            * Returns the journal folders before and after the current journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1449            *
1450            * @param folderId the primary key of the current journal folder
1451            * @param groupId the group ID
1452            * @param parentFolderId the parent folder ID
1453            * @param status the status
1454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1455            * @return the previous, current, and next journal folder
1456            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1457            */
1458            public static JournalFolder[] findByG_P_S_PrevAndNext(long folderId,
1459                    long groupId, long parentFolderId, int status,
1460                    OrderByComparator<JournalFolder> orderByComparator)
1461                    throws com.liferay.portlet.journal.NoSuchFolderException {
1462                    return getPersistence()
1463                                       .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId,
1464                            status, orderByComparator);
1465            }
1466    
1467            /**
1468            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1469            *
1470            * @param groupId the group ID
1471            * @param parentFolderId the parent folder ID
1472            * @param status the status
1473            * @return the matching journal folders that the user has permission to view
1474            */
1475            public static List<JournalFolder> filterFindByG_P_S(long groupId,
1476                    long parentFolderId, int status) {
1477                    return getPersistence()
1478                                       .filterFindByG_P_S(groupId, parentFolderId, status);
1479            }
1480    
1481            /**
1482            * Returns a range of all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#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 groupId the group ID
1489            * @param parentFolderId the parent folder ID
1490            * @param status the status
1491            * @param start the lower bound of the range of journal folders
1492            * @param end the upper bound of the range of journal folders (not inclusive)
1493            * @return the range of matching journal folders that the user has permission to view
1494            */
1495            public static List<JournalFolder> filterFindByG_P_S(long groupId,
1496                    long parentFolderId, int status, int start, int end) {
1497                    return getPersistence()
1498                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1499                            end);
1500            }
1501    
1502            /**
1503            * 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;.
1504            *
1505            * <p>
1506            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1507            * </p>
1508            *
1509            * @param groupId the group ID
1510            * @param parentFolderId the parent folder ID
1511            * @param status the status
1512            * @param start the lower bound of the range of journal folders
1513            * @param end the upper bound of the range of journal folders (not inclusive)
1514            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1515            * @return the ordered range of matching journal folders that the user has permission to view
1516            */
1517            public static List<JournalFolder> filterFindByG_P_S(long groupId,
1518                    long parentFolderId, int status, int start, int end,
1519                    OrderByComparator<JournalFolder> orderByComparator) {
1520                    return getPersistence()
1521                                       .filterFindByG_P_S(groupId, parentFolderId, status, start,
1522                            end, orderByComparator);
1523            }
1524    
1525            /**
1526            * 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;.
1527            *
1528            * @param folderId the primary key of the current journal folder
1529            * @param groupId the group ID
1530            * @param parentFolderId the parent folder ID
1531            * @param status the status
1532            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1533            * @return the previous, current, and next journal folder
1534            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1535            */
1536            public static JournalFolder[] filterFindByG_P_S_PrevAndNext(long folderId,
1537                    long groupId, long parentFolderId, int status,
1538                    OrderByComparator<JournalFolder> orderByComparator)
1539                    throws com.liferay.portlet.journal.NoSuchFolderException {
1540                    return getPersistence()
1541                                       .filterFindByG_P_S_PrevAndNext(folderId, groupId,
1542                            parentFolderId, status, orderByComparator);
1543            }
1544    
1545            /**
1546            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63; from the database.
1547            *
1548            * @param groupId the group ID
1549            * @param parentFolderId the parent folder ID
1550            * @param status the status
1551            */
1552            public static void removeByG_P_S(long groupId, long parentFolderId,
1553                    int status) {
1554                    getPersistence().removeByG_P_S(groupId, parentFolderId, status);
1555            }
1556    
1557            /**
1558            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1559            *
1560            * @param groupId the group ID
1561            * @param parentFolderId the parent folder ID
1562            * @param status the status
1563            * @return the number of matching journal folders
1564            */
1565            public static int countByG_P_S(long groupId, long parentFolderId, int status) {
1566                    return getPersistence().countByG_P_S(groupId, parentFolderId, status);
1567            }
1568    
1569            /**
1570            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status = &#63;.
1571            *
1572            * @param groupId the group ID
1573            * @param parentFolderId the parent folder ID
1574            * @param status the status
1575            * @return the number of matching journal folders that the user has permission to view
1576            */
1577            public static int filterCountByG_P_S(long groupId, long parentFolderId,
1578                    int status) {
1579                    return getPersistence()
1580                                       .filterCountByG_P_S(groupId, parentFolderId, status);
1581            }
1582    
1583            /**
1584            * Returns all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1585            *
1586            * @param groupId the group ID
1587            * @param parentFolderId the parent folder ID
1588            * @param status the status
1589            * @return the matching journal folders
1590            */
1591            public static List<JournalFolder> findByG_P_NotS(long groupId,
1592                    long parentFolderId, int status) {
1593                    return getPersistence().findByG_P_NotS(groupId, parentFolderId, status);
1594            }
1595    
1596            /**
1597            * Returns a range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1598            *
1599            * <p>
1600            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1601            * </p>
1602            *
1603            * @param groupId the group ID
1604            * @param parentFolderId the parent folder ID
1605            * @param status the status
1606            * @param start the lower bound of the range of journal folders
1607            * @param end the upper bound of the range of journal folders (not inclusive)
1608            * @return the range of matching journal folders
1609            */
1610            public static List<JournalFolder> findByG_P_NotS(long groupId,
1611                    long parentFolderId, int status, int start, int end) {
1612                    return getPersistence()
1613                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end);
1614            }
1615    
1616            /**
1617            * Returns an ordered range of all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1618            *
1619            * <p>
1620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1621            * </p>
1622            *
1623            * @param groupId the group ID
1624            * @param parentFolderId the parent folder ID
1625            * @param status the status
1626            * @param start the lower bound of the range of journal folders
1627            * @param end the upper bound of the range of journal folders (not inclusive)
1628            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1629            * @return the ordered range of matching journal folders
1630            */
1631            public static List<JournalFolder> findByG_P_NotS(long groupId,
1632                    long parentFolderId, int status, int start, int end,
1633                    OrderByComparator<JournalFolder> orderByComparator) {
1634                    return getPersistence()
1635                                       .findByG_P_NotS(groupId, parentFolderId, status, start, end,
1636                            orderByComparator);
1637            }
1638    
1639            /**
1640            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1641            *
1642            * @param groupId the group ID
1643            * @param parentFolderId the parent folder ID
1644            * @param status the status
1645            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1646            * @return the first matching journal folder
1647            * @throws NoSuchFolderException if a matching journal folder could not be found
1648            */
1649            public static JournalFolder findByG_P_NotS_First(long groupId,
1650                    long parentFolderId, int status,
1651                    OrderByComparator<JournalFolder> orderByComparator)
1652                    throws com.liferay.portlet.journal.NoSuchFolderException {
1653                    return getPersistence()
1654                                       .findByG_P_NotS_First(groupId, parentFolderId, status,
1655                            orderByComparator);
1656            }
1657    
1658            /**
1659            * Returns the first journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1660            *
1661            * @param groupId the group ID
1662            * @param parentFolderId the parent folder ID
1663            * @param status the status
1664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1665            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1666            */
1667            public static JournalFolder fetchByG_P_NotS_First(long groupId,
1668                    long parentFolderId, int status,
1669                    OrderByComparator<JournalFolder> orderByComparator) {
1670                    return getPersistence()
1671                                       .fetchByG_P_NotS_First(groupId, parentFolderId, status,
1672                            orderByComparator);
1673            }
1674    
1675            /**
1676            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1677            *
1678            * @param groupId the group ID
1679            * @param parentFolderId the parent folder ID
1680            * @param status the status
1681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1682            * @return the last matching journal folder
1683            * @throws NoSuchFolderException if a matching journal folder could not be found
1684            */
1685            public static JournalFolder findByG_P_NotS_Last(long groupId,
1686                    long parentFolderId, int status,
1687                    OrderByComparator<JournalFolder> orderByComparator)
1688                    throws com.liferay.portlet.journal.NoSuchFolderException {
1689                    return getPersistence()
1690                                       .findByG_P_NotS_Last(groupId, parentFolderId, status,
1691                            orderByComparator);
1692            }
1693    
1694            /**
1695            * Returns the last journal folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1696            *
1697            * @param groupId the group ID
1698            * @param parentFolderId the parent folder ID
1699            * @param status the status
1700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1701            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1702            */
1703            public static JournalFolder fetchByG_P_NotS_Last(long groupId,
1704                    long parentFolderId, int status,
1705                    OrderByComparator<JournalFolder> orderByComparator) {
1706                    return getPersistence()
1707                                       .fetchByG_P_NotS_Last(groupId, parentFolderId, status,
1708                            orderByComparator);
1709            }
1710    
1711            /**
1712            * 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;.
1713            *
1714            * @param folderId the primary key of the current journal folder
1715            * @param groupId the group ID
1716            * @param parentFolderId the parent folder ID
1717            * @param status the status
1718            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1719            * @return the previous, current, and next journal folder
1720            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1721            */
1722            public static JournalFolder[] findByG_P_NotS_PrevAndNext(long folderId,
1723                    long groupId, long parentFolderId, int status,
1724                    OrderByComparator<JournalFolder> orderByComparator)
1725                    throws com.liferay.portlet.journal.NoSuchFolderException {
1726                    return getPersistence()
1727                                       .findByG_P_NotS_PrevAndNext(folderId, groupId,
1728                            parentFolderId, status, orderByComparator);
1729            }
1730    
1731            /**
1732            * Returns all the journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1733            *
1734            * @param groupId the group ID
1735            * @param parentFolderId the parent folder ID
1736            * @param status the status
1737            * @return the matching journal folders that the user has permission to view
1738            */
1739            public static List<JournalFolder> filterFindByG_P_NotS(long groupId,
1740                    long parentFolderId, int status) {
1741                    return getPersistence()
1742                                       .filterFindByG_P_NotS(groupId, parentFolderId, status);
1743            }
1744    
1745            /**
1746            * 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;.
1747            *
1748            * <p>
1749            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1750            * </p>
1751            *
1752            * @param groupId the group ID
1753            * @param parentFolderId the parent folder ID
1754            * @param status the status
1755            * @param start the lower bound of the range of journal folders
1756            * @param end the upper bound of the range of journal folders (not inclusive)
1757            * @return the range of matching journal folders that the user has permission to view
1758            */
1759            public static List<JournalFolder> filterFindByG_P_NotS(long groupId,
1760                    long parentFolderId, int status, int start, int end) {
1761                    return getPersistence()
1762                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
1763                            start, end);
1764            }
1765    
1766            /**
1767            * 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;.
1768            *
1769            * <p>
1770            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1771            * </p>
1772            *
1773            * @param groupId the group ID
1774            * @param parentFolderId the parent folder ID
1775            * @param status the status
1776            * @param start the lower bound of the range of journal folders
1777            * @param end the upper bound of the range of journal folders (not inclusive)
1778            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1779            * @return the ordered range of matching journal folders that the user has permission to view
1780            */
1781            public static List<JournalFolder> filterFindByG_P_NotS(long groupId,
1782                    long parentFolderId, int status, int start, int end,
1783                    OrderByComparator<JournalFolder> orderByComparator) {
1784                    return getPersistence()
1785                                       .filterFindByG_P_NotS(groupId, parentFolderId, status,
1786                            start, end, orderByComparator);
1787            }
1788    
1789            /**
1790            * 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;.
1791            *
1792            * @param folderId the primary key of the current journal folder
1793            * @param groupId the group ID
1794            * @param parentFolderId the parent folder ID
1795            * @param status the status
1796            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1797            * @return the previous, current, and next journal folder
1798            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
1799            */
1800            public static JournalFolder[] filterFindByG_P_NotS_PrevAndNext(
1801                    long folderId, long groupId, long parentFolderId, int status,
1802                    OrderByComparator<JournalFolder> orderByComparator)
1803                    throws com.liferay.portlet.journal.NoSuchFolderException {
1804                    return getPersistence()
1805                                       .filterFindByG_P_NotS_PrevAndNext(folderId, groupId,
1806                            parentFolderId, status, orderByComparator);
1807            }
1808    
1809            /**
1810            * Removes all the journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1811            *
1812            * @param groupId the group ID
1813            * @param parentFolderId the parent folder ID
1814            * @param status the status
1815            */
1816            public static void removeByG_P_NotS(long groupId, long parentFolderId,
1817                    int status) {
1818                    getPersistence().removeByG_P_NotS(groupId, parentFolderId, status);
1819            }
1820    
1821            /**
1822            * Returns the number of journal folders where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1823            *
1824            * @param groupId the group ID
1825            * @param parentFolderId the parent folder ID
1826            * @param status the status
1827            * @return the number of matching journal folders
1828            */
1829            public static int countByG_P_NotS(long groupId, long parentFolderId,
1830                    int status) {
1831                    return getPersistence().countByG_P_NotS(groupId, parentFolderId, status);
1832            }
1833    
1834            /**
1835            * Returns the number of journal folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1836            *
1837            * @param groupId the group ID
1838            * @param parentFolderId the parent folder ID
1839            * @param status the status
1840            * @return the number of matching journal folders that the user has permission to view
1841            */
1842            public static int filterCountByG_P_NotS(long groupId, long parentFolderId,
1843                    int status) {
1844                    return getPersistence()
1845                                       .filterCountByG_P_NotS(groupId, parentFolderId, status);
1846            }
1847    
1848            /**
1849            * Returns all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1850            *
1851            * @param folderId the folder ID
1852            * @param companyId the company ID
1853            * @param parentFolderId the parent folder ID
1854            * @param status the status
1855            * @return the matching journal folders
1856            */
1857            public static List<JournalFolder> findByF_C_P_NotS(long folderId,
1858                    long companyId, long parentFolderId, int status) {
1859                    return getPersistence()
1860                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId, status);
1861            }
1862    
1863            /**
1864            * Returns a range of all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1865            *
1866            * <p>
1867            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1868            * </p>
1869            *
1870            * @param folderId the folder ID
1871            * @param companyId the company ID
1872            * @param parentFolderId the parent folder ID
1873            * @param status the status
1874            * @param start the lower bound of the range of journal folders
1875            * @param end the upper bound of the range of journal folders (not inclusive)
1876            * @return the range of matching journal folders
1877            */
1878            public static List<JournalFolder> findByF_C_P_NotS(long folderId,
1879                    long companyId, long parentFolderId, int status, int start, int end) {
1880                    return getPersistence()
1881                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId,
1882                            status, start, end);
1883            }
1884    
1885            /**
1886            * Returns an ordered range of all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1887            *
1888            * <p>
1889            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
1890            * </p>
1891            *
1892            * @param folderId the folder ID
1893            * @param companyId the company ID
1894            * @param parentFolderId the parent folder ID
1895            * @param status the status
1896            * @param start the lower bound of the range of journal folders
1897            * @param end the upper bound of the range of journal folders (not inclusive)
1898            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1899            * @return the ordered range of matching journal folders
1900            */
1901            public static List<JournalFolder> findByF_C_P_NotS(long folderId,
1902                    long companyId, long parentFolderId, int status, int start, int end,
1903                    OrderByComparator<JournalFolder> orderByComparator) {
1904                    return getPersistence()
1905                                       .findByF_C_P_NotS(folderId, companyId, parentFolderId,
1906                            status, start, end, orderByComparator);
1907            }
1908    
1909            /**
1910            * Returns the first journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1911            *
1912            * @param folderId the folder ID
1913            * @param companyId the company ID
1914            * @param parentFolderId the parent folder ID
1915            * @param status the status
1916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1917            * @return the first matching journal folder
1918            * @throws NoSuchFolderException if a matching journal folder could not be found
1919            */
1920            public static JournalFolder findByF_C_P_NotS_First(long folderId,
1921                    long companyId, long parentFolderId, int status,
1922                    OrderByComparator<JournalFolder> orderByComparator)
1923                    throws com.liferay.portlet.journal.NoSuchFolderException {
1924                    return getPersistence()
1925                                       .findByF_C_P_NotS_First(folderId, companyId, parentFolderId,
1926                            status, orderByComparator);
1927            }
1928    
1929            /**
1930            * Returns the first journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1931            *
1932            * @param folderId the folder ID
1933            * @param companyId the company ID
1934            * @param parentFolderId the parent folder ID
1935            * @param status the status
1936            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1937            * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found
1938            */
1939            public static JournalFolder fetchByF_C_P_NotS_First(long folderId,
1940                    long companyId, long parentFolderId, int status,
1941                    OrderByComparator<JournalFolder> orderByComparator) {
1942                    return getPersistence()
1943                                       .fetchByF_C_P_NotS_First(folderId, companyId,
1944                            parentFolderId, status, orderByComparator);
1945            }
1946    
1947            /**
1948            * Returns the last journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1949            *
1950            * @param folderId the folder ID
1951            * @param companyId the company ID
1952            * @param parentFolderId the parent folder ID
1953            * @param status the status
1954            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1955            * @return the last matching journal folder
1956            * @throws NoSuchFolderException if a matching journal folder could not be found
1957            */
1958            public static JournalFolder findByF_C_P_NotS_Last(long folderId,
1959                    long companyId, long parentFolderId, int status,
1960                    OrderByComparator<JournalFolder> orderByComparator)
1961                    throws com.liferay.portlet.journal.NoSuchFolderException {
1962                    return getPersistence()
1963                                       .findByF_C_P_NotS_Last(folderId, companyId, parentFolderId,
1964                            status, orderByComparator);
1965            }
1966    
1967            /**
1968            * Returns the last journal folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1969            *
1970            * @param folderId the folder ID
1971            * @param companyId the company ID
1972            * @param parentFolderId the parent folder ID
1973            * @param status the status
1974            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1975            * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found
1976            */
1977            public static JournalFolder fetchByF_C_P_NotS_Last(long folderId,
1978                    long companyId, long parentFolderId, int status,
1979                    OrderByComparator<JournalFolder> orderByComparator) {
1980                    return getPersistence()
1981                                       .fetchByF_C_P_NotS_Last(folderId, companyId, parentFolderId,
1982                            status, orderByComparator);
1983            }
1984    
1985            /**
1986            * Removes all the journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1987            *
1988            * @param folderId the folder ID
1989            * @param companyId the company ID
1990            * @param parentFolderId the parent folder ID
1991            * @param status the status
1992            */
1993            public static void removeByF_C_P_NotS(long folderId, long companyId,
1994                    long parentFolderId, int status) {
1995                    getPersistence()
1996                            .removeByF_C_P_NotS(folderId, companyId, parentFolderId, status);
1997            }
1998    
1999            /**
2000            * Returns the number of journal folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
2001            *
2002            * @param folderId the folder ID
2003            * @param companyId the company ID
2004            * @param parentFolderId the parent folder ID
2005            * @param status the status
2006            * @return the number of matching journal folders
2007            */
2008            public static int countByF_C_P_NotS(long folderId, long companyId,
2009                    long parentFolderId, int status) {
2010                    return getPersistence()
2011                                       .countByF_C_P_NotS(folderId, companyId, parentFolderId,
2012                            status);
2013            }
2014    
2015            /**
2016            * Caches the journal folder in the entity cache if it is enabled.
2017            *
2018            * @param journalFolder the journal folder
2019            */
2020            public static void cacheResult(JournalFolder journalFolder) {
2021                    getPersistence().cacheResult(journalFolder);
2022            }
2023    
2024            /**
2025            * Caches the journal folders in the entity cache if it is enabled.
2026            *
2027            * @param journalFolders the journal folders
2028            */
2029            public static void cacheResult(List<JournalFolder> journalFolders) {
2030                    getPersistence().cacheResult(journalFolders);
2031            }
2032    
2033            /**
2034            * Creates a new journal folder with the primary key. Does not add the journal folder to the database.
2035            *
2036            * @param folderId the primary key for the new journal folder
2037            * @return the new journal folder
2038            */
2039            public static JournalFolder create(long folderId) {
2040                    return getPersistence().create(folderId);
2041            }
2042    
2043            /**
2044            * Removes the journal folder with the primary key from the database. Also notifies the appropriate model listeners.
2045            *
2046            * @param folderId the primary key of the journal folder
2047            * @return the journal folder that was removed
2048            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
2049            */
2050            public static JournalFolder remove(long folderId)
2051                    throws com.liferay.portlet.journal.NoSuchFolderException {
2052                    return getPersistence().remove(folderId);
2053            }
2054    
2055            public static JournalFolder updateImpl(JournalFolder journalFolder) {
2056                    return getPersistence().updateImpl(journalFolder);
2057            }
2058    
2059            /**
2060            * Returns the journal folder with the primary key or throws a {@link NoSuchFolderException} if it could not be found.
2061            *
2062            * @param folderId the primary key of the journal folder
2063            * @return the journal folder
2064            * @throws NoSuchFolderException if a journal folder with the primary key could not be found
2065            */
2066            public static JournalFolder findByPrimaryKey(long folderId)
2067                    throws com.liferay.portlet.journal.NoSuchFolderException {
2068                    return getPersistence().findByPrimaryKey(folderId);
2069            }
2070    
2071            /**
2072            * Returns the journal folder with the primary key or returns <code>null</code> if it could not be found.
2073            *
2074            * @param folderId the primary key of the journal folder
2075            * @return the journal folder, or <code>null</code> if a journal folder with the primary key could not be found
2076            */
2077            public static JournalFolder fetchByPrimaryKey(long folderId) {
2078                    return getPersistence().fetchByPrimaryKey(folderId);
2079            }
2080    
2081            public static java.util.Map<java.io.Serializable, JournalFolder> fetchByPrimaryKeys(
2082                    java.util.Set<java.io.Serializable> primaryKeys) {
2083                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2084            }
2085    
2086            /**
2087            * Returns all the journal folders.
2088            *
2089            * @return the journal folders
2090            */
2091            public static List<JournalFolder> findAll() {
2092                    return getPersistence().findAll();
2093            }
2094    
2095            /**
2096            * Returns a range of all the journal folders.
2097            *
2098            * <p>
2099            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
2100            * </p>
2101            *
2102            * @param start the lower bound of the range of journal folders
2103            * @param end the upper bound of the range of journal folders (not inclusive)
2104            * @return the range of journal folders
2105            */
2106            public static List<JournalFolder> findAll(int start, int end) {
2107                    return getPersistence().findAll(start, end);
2108            }
2109    
2110            /**
2111            * Returns an ordered range of all the journal folders.
2112            *
2113            * <p>
2114            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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.
2115            * </p>
2116            *
2117            * @param start the lower bound of the range of journal folders
2118            * @param end the upper bound of the range of journal folders (not inclusive)
2119            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2120            * @return the ordered range of journal folders
2121            */
2122            public static List<JournalFolder> findAll(int start, int end,
2123                    OrderByComparator<JournalFolder> orderByComparator) {
2124                    return getPersistence().findAll(start, end, orderByComparator);
2125            }
2126    
2127            /**
2128            * Removes all the journal folders from the database.
2129            */
2130            public static void removeAll() {
2131                    getPersistence().removeAll();
2132            }
2133    
2134            /**
2135            * Returns the number of journal folders.
2136            *
2137            * @return the number of journal folders
2138            */
2139            public static int countAll() {
2140                    return getPersistence().countAll();
2141            }
2142    
2143            public static JournalFolderPersistence getPersistence() {
2144                    if (_persistence == null) {
2145                            _persistence = (JournalFolderPersistence)PortalBeanLocatorUtil.locate(JournalFolderPersistence.class.getName());
2146    
2147                            ReferenceRegistry.registerReference(JournalFolderUtil.class,
2148                                    "_persistence");
2149                    }
2150    
2151                    return _persistence;
2152            }
2153    
2154            /**
2155             * @deprecated As of 6.2.0
2156             */
2157            @Deprecated
2158            public void setPersistence(JournalFolderPersistence persistence) {
2159            }
2160    
2161            private static JournalFolderPersistence _persistence;
2162    }