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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and groupId = ? 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 = ? and groupId = ? 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 = ? and groupId = ? 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 = ? and groupId = ? 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 = ? and groupId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ? 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 = ? and companyId = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ? 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 = ? and parentFolderId = ?. 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 = ? and parentFolderId = ?. 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 = ? and name = ? 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 = ? and name = ? 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 = ? and name = ? 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 = ? and name = ? 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 = ? and name = ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ?. 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 = ? and status ≠ ? 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 = ? and status ≠ ?. 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 = ? and parentFolderId = ? and name = ? 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 = ? and parentFolderId = ? and name = ? 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 = ? and parentFolderId = ? and name = ? 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 = ? and parentFolderId = ? and name = ? 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 = ? and parentFolderId = ? and name = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ? 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status = ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ? 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 = ? and parentFolderId = ? and status ≠ ?. 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 = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ? 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 > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 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 }