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.documentlibrary.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.documentlibrary.model.DLFolder; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the document library folder service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFolderPersistenceImpl} 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 DLFolderPersistence 038 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFolderPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class DLFolderUtil { 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(DLFolder dlFolder) { 060 getPersistence().clearCache(dlFolder); 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<DLFolder> findWithDynamicQuery(DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<DLFolder> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<DLFolder> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<DLFolder> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static DLFolder update(DLFolder dlFolder) { 100 return getPersistence().update(dlFolder); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static DLFolder update(DLFolder dlFolder, 107 ServiceContext serviceContext) { 108 return getPersistence().update(dlFolder, serviceContext); 109 } 110 111 /** 112 * Returns all the document library folders where uuid = ?. 113 * 114 * @param uuid the uuid 115 * @return the matching document library folders 116 */ 117 public static List<DLFolder> findByUuid(java.lang.String uuid) { 118 return getPersistence().findByUuid(uuid); 119 } 120 121 /** 122 * Returns a range of all the document library folders where uuid = ?. 123 * 124 * <p> 125 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 126 * </p> 127 * 128 * @param uuid the uuid 129 * @param start the lower bound of the range of document library folders 130 * @param end the upper bound of the range of document library folders (not inclusive) 131 * @return the range of matching document library folders 132 */ 133 public static List<DLFolder> findByUuid(java.lang.String uuid, int start, 134 int end) { 135 return getPersistence().findByUuid(uuid, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the document library folders where uuid = ?. 140 * 141 * <p> 142 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 143 * </p> 144 * 145 * @param uuid the uuid 146 * @param start the lower bound of the range of document library folders 147 * @param end the upper bound of the range of document library folders (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching document library folders 150 */ 151 public static List<DLFolder> findByUuid(java.lang.String uuid, int start, 152 int end, OrderByComparator<DLFolder> orderByComparator) { 153 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns an ordered range of all the document library folders where uuid = ?. 158 * 159 * <p> 160 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 161 * </p> 162 * 163 * @param uuid the uuid 164 * @param start the lower bound of the range of document library folders 165 * @param end the upper bound of the range of document library folders (not inclusive) 166 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 167 * @param retrieveFromCache whether to retrieve from the finder cache 168 * @return the ordered range of matching document library folders 169 */ 170 public static List<DLFolder> findByUuid(java.lang.String uuid, int start, 171 int end, OrderByComparator<DLFolder> orderByComparator, 172 boolean retrieveFromCache) { 173 return getPersistence() 174 .findByUuid(uuid, start, end, orderByComparator, 175 retrieveFromCache); 176 } 177 178 /** 179 * Returns the first document library folder in the ordered set where uuid = ?. 180 * 181 * @param uuid the uuid 182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 183 * @return the first matching document library folder 184 * @throws NoSuchFolderException if a matching document library folder could not be found 185 */ 186 public static DLFolder findByUuid_First(java.lang.String uuid, 187 OrderByComparator<DLFolder> orderByComparator) 188 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 189 return getPersistence().findByUuid_First(uuid, orderByComparator); 190 } 191 192 /** 193 * Returns the first document library folder in the ordered set where uuid = ?. 194 * 195 * @param uuid the uuid 196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 197 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 198 */ 199 public static DLFolder fetchByUuid_First(java.lang.String uuid, 200 OrderByComparator<DLFolder> orderByComparator) { 201 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 202 } 203 204 /** 205 * Returns the last document library folder in the ordered set where uuid = ?. 206 * 207 * @param uuid the uuid 208 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 209 * @return the last matching document library folder 210 * @throws NoSuchFolderException if a matching document library folder could not be found 211 */ 212 public static DLFolder findByUuid_Last(java.lang.String uuid, 213 OrderByComparator<DLFolder> orderByComparator) 214 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 215 return getPersistence().findByUuid_Last(uuid, orderByComparator); 216 } 217 218 /** 219 * Returns the last document library folder in the ordered set where uuid = ?. 220 * 221 * @param uuid the uuid 222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 223 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 224 */ 225 public static DLFolder fetchByUuid_Last(java.lang.String uuid, 226 OrderByComparator<DLFolder> orderByComparator) { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the document library folders before and after the current document library folder in the ordered set where uuid = ?. 232 * 233 * @param folderId the primary key of the current document library folder 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next document library folder 237 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 238 */ 239 public static DLFolder[] findByUuid_PrevAndNext(long folderId, 240 java.lang.String uuid, OrderByComparator<DLFolder> orderByComparator) 241 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 242 return getPersistence() 243 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 244 } 245 246 /** 247 * Removes all the document library folders where uuid = ? from the database. 248 * 249 * @param uuid the uuid 250 */ 251 public static void removeByUuid(java.lang.String uuid) { 252 getPersistence().removeByUuid(uuid); 253 } 254 255 /** 256 * Returns the number of document library folders where uuid = ?. 257 * 258 * @param uuid the uuid 259 * @return the number of matching document library folders 260 */ 261 public static int countByUuid(java.lang.String uuid) { 262 return getPersistence().countByUuid(uuid); 263 } 264 265 /** 266 * Returns the document library folder where uuid = ? and groupId = ? or throws a {@link NoSuchFolderException} if it could not be found. 267 * 268 * @param uuid the uuid 269 * @param groupId the group ID 270 * @return the matching document library folder 271 * @throws NoSuchFolderException if a matching document library folder could not be found 272 */ 273 public static DLFolder findByUUID_G(java.lang.String uuid, long groupId) 274 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 275 return getPersistence().findByUUID_G(uuid, groupId); 276 } 277 278 /** 279 * Returns the document library folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 280 * 281 * @param uuid the uuid 282 * @param groupId the group ID 283 * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found 284 */ 285 public static DLFolder fetchByUUID_G(java.lang.String uuid, long groupId) { 286 return getPersistence().fetchByUUID_G(uuid, groupId); 287 } 288 289 /** 290 * Returns the document library folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 291 * 292 * @param uuid the uuid 293 * @param groupId the group ID 294 * @param retrieveFromCache whether to retrieve from the finder cache 295 * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found 296 */ 297 public static DLFolder fetchByUUID_G(java.lang.String uuid, long groupId, 298 boolean retrieveFromCache) { 299 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 300 } 301 302 /** 303 * Removes the document library folder where uuid = ? and groupId = ? from the database. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @return the document library folder that was removed 308 */ 309 public static DLFolder removeByUUID_G(java.lang.String uuid, long groupId) 310 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 311 return getPersistence().removeByUUID_G(uuid, groupId); 312 } 313 314 /** 315 * Returns the number of document library folders where uuid = ? and groupId = ?. 316 * 317 * @param uuid the uuid 318 * @param groupId the group ID 319 * @return the number of matching document library folders 320 */ 321 public static int countByUUID_G(java.lang.String uuid, long groupId) { 322 return getPersistence().countByUUID_G(uuid, groupId); 323 } 324 325 /** 326 * Returns all the document library folders where uuid = ? and companyId = ?. 327 * 328 * @param uuid the uuid 329 * @param companyId the company ID 330 * @return the matching document library folders 331 */ 332 public static List<DLFolder> findByUuid_C(java.lang.String uuid, 333 long companyId) { 334 return getPersistence().findByUuid_C(uuid, companyId); 335 } 336 337 /** 338 * Returns a range of all the document library folders where uuid = ? and companyId = ?. 339 * 340 * <p> 341 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 342 * </p> 343 * 344 * @param uuid the uuid 345 * @param companyId the company ID 346 * @param start the lower bound of the range of document library folders 347 * @param end the upper bound of the range of document library folders (not inclusive) 348 * @return the range of matching document library folders 349 */ 350 public static List<DLFolder> findByUuid_C(java.lang.String uuid, 351 long companyId, int start, int end) { 352 return getPersistence().findByUuid_C(uuid, companyId, start, end); 353 } 354 355 /** 356 * Returns an ordered range of all the document library folders where uuid = ? and companyId = ?. 357 * 358 * <p> 359 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 360 * </p> 361 * 362 * @param uuid the uuid 363 * @param companyId the company ID 364 * @param start the lower bound of the range of document library folders 365 * @param end the upper bound of the range of document library folders (not inclusive) 366 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 367 * @return the ordered range of matching document library folders 368 */ 369 public static List<DLFolder> findByUuid_C(java.lang.String uuid, 370 long companyId, int start, int end, 371 OrderByComparator<DLFolder> orderByComparator) { 372 return getPersistence() 373 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 374 } 375 376 /** 377 * Returns an ordered range of all the document library folders where uuid = ? and companyId = ?. 378 * 379 * <p> 380 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 381 * </p> 382 * 383 * @param uuid the uuid 384 * @param companyId the company ID 385 * @param start the lower bound of the range of document library folders 386 * @param end the upper bound of the range of document library folders (not inclusive) 387 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 388 * @param retrieveFromCache whether to retrieve from the finder cache 389 * @return the ordered range of matching document library folders 390 */ 391 public static List<DLFolder> findByUuid_C(java.lang.String uuid, 392 long companyId, int start, int end, 393 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 394 return getPersistence() 395 .findByUuid_C(uuid, companyId, start, end, 396 orderByComparator, retrieveFromCache); 397 } 398 399 /** 400 * Returns the first document library folder in the ordered set where uuid = ? and companyId = ?. 401 * 402 * @param uuid the uuid 403 * @param companyId the company ID 404 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 405 * @return the first matching document library folder 406 * @throws NoSuchFolderException if a matching document library folder could not be found 407 */ 408 public static DLFolder findByUuid_C_First(java.lang.String uuid, 409 long companyId, OrderByComparator<DLFolder> orderByComparator) 410 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 411 return getPersistence() 412 .findByUuid_C_First(uuid, companyId, orderByComparator); 413 } 414 415 /** 416 * Returns the first document library folder in the ordered set where uuid = ? and companyId = ?. 417 * 418 * @param uuid the uuid 419 * @param companyId the company ID 420 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 421 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 422 */ 423 public static DLFolder fetchByUuid_C_First(java.lang.String uuid, 424 long companyId, OrderByComparator<DLFolder> orderByComparator) { 425 return getPersistence() 426 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 427 } 428 429 /** 430 * Returns the last document library folder in the ordered set where uuid = ? and companyId = ?. 431 * 432 * @param uuid the uuid 433 * @param companyId the company ID 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the last matching document library folder 436 * @throws NoSuchFolderException if a matching document library folder could not be found 437 */ 438 public static DLFolder findByUuid_C_Last(java.lang.String uuid, 439 long companyId, OrderByComparator<DLFolder> orderByComparator) 440 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 441 return getPersistence() 442 .findByUuid_C_Last(uuid, companyId, orderByComparator); 443 } 444 445 /** 446 * Returns the last document library folder in the ordered set where uuid = ? and companyId = ?. 447 * 448 * @param uuid the uuid 449 * @param companyId the company ID 450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 451 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 452 */ 453 public static DLFolder fetchByUuid_C_Last(java.lang.String uuid, 454 long companyId, OrderByComparator<DLFolder> orderByComparator) { 455 return getPersistence() 456 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 457 } 458 459 /** 460 * Returns the document library folders before and after the current document library folder in the ordered set where uuid = ? and companyId = ?. 461 * 462 * @param folderId the primary key of the current document library folder 463 * @param uuid the uuid 464 * @param companyId the company ID 465 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 466 * @return the previous, current, and next document library folder 467 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 468 */ 469 public static DLFolder[] findByUuid_C_PrevAndNext(long folderId, 470 java.lang.String uuid, long companyId, 471 OrderByComparator<DLFolder> orderByComparator) 472 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 473 return getPersistence() 474 .findByUuid_C_PrevAndNext(folderId, uuid, companyId, 475 orderByComparator); 476 } 477 478 /** 479 * Removes all the document library folders where uuid = ? and companyId = ? from the database. 480 * 481 * @param uuid the uuid 482 * @param companyId the company ID 483 */ 484 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 485 getPersistence().removeByUuid_C(uuid, companyId); 486 } 487 488 /** 489 * Returns the number of document library folders where uuid = ? and companyId = ?. 490 * 491 * @param uuid the uuid 492 * @param companyId the company ID 493 * @return the number of matching document library folders 494 */ 495 public static int countByUuid_C(java.lang.String uuid, long companyId) { 496 return getPersistence().countByUuid_C(uuid, companyId); 497 } 498 499 /** 500 * Returns all the document library folders where groupId = ?. 501 * 502 * @param groupId the group ID 503 * @return the matching document library folders 504 */ 505 public static List<DLFolder> findByGroupId(long groupId) { 506 return getPersistence().findByGroupId(groupId); 507 } 508 509 /** 510 * Returns a range of all the document library folders where groupId = ?. 511 * 512 * <p> 513 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 514 * </p> 515 * 516 * @param groupId the group ID 517 * @param start the lower bound of the range of document library folders 518 * @param end the upper bound of the range of document library folders (not inclusive) 519 * @return the range of matching document library folders 520 */ 521 public static List<DLFolder> findByGroupId(long groupId, int start, int end) { 522 return getPersistence().findByGroupId(groupId, start, end); 523 } 524 525 /** 526 * Returns an ordered range of all the document library folders where groupId = ?. 527 * 528 * <p> 529 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 530 * </p> 531 * 532 * @param groupId the group ID 533 * @param start the lower bound of the range of document library folders 534 * @param end the upper bound of the range of document library folders (not inclusive) 535 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 536 * @return the ordered range of matching document library folders 537 */ 538 public static List<DLFolder> findByGroupId(long groupId, int start, 539 int end, OrderByComparator<DLFolder> orderByComparator) { 540 return getPersistence() 541 .findByGroupId(groupId, start, end, orderByComparator); 542 } 543 544 /** 545 * Returns an ordered range of all the document library folders where groupId = ?. 546 * 547 * <p> 548 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 549 * </p> 550 * 551 * @param groupId the group ID 552 * @param start the lower bound of the range of document library folders 553 * @param end the upper bound of the range of document library folders (not inclusive) 554 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 555 * @param retrieveFromCache whether to retrieve from the finder cache 556 * @return the ordered range of matching document library folders 557 */ 558 public static List<DLFolder> findByGroupId(long groupId, int start, 559 int end, OrderByComparator<DLFolder> orderByComparator, 560 boolean retrieveFromCache) { 561 return getPersistence() 562 .findByGroupId(groupId, start, end, orderByComparator, 563 retrieveFromCache); 564 } 565 566 /** 567 * Returns the first document library folder in the ordered set where groupId = ?. 568 * 569 * @param groupId the group ID 570 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 571 * @return the first matching document library folder 572 * @throws NoSuchFolderException if a matching document library folder could not be found 573 */ 574 public static DLFolder findByGroupId_First(long groupId, 575 OrderByComparator<DLFolder> orderByComparator) 576 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 577 return getPersistence().findByGroupId_First(groupId, orderByComparator); 578 } 579 580 /** 581 * Returns the first document library folder in the ordered set where groupId = ?. 582 * 583 * @param groupId the group ID 584 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 585 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 586 */ 587 public static DLFolder fetchByGroupId_First(long groupId, 588 OrderByComparator<DLFolder> orderByComparator) { 589 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 590 } 591 592 /** 593 * Returns the last document library folder in the ordered set where groupId = ?. 594 * 595 * @param groupId the group ID 596 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 597 * @return the last matching document library folder 598 * @throws NoSuchFolderException if a matching document library folder could not be found 599 */ 600 public static DLFolder findByGroupId_Last(long groupId, 601 OrderByComparator<DLFolder> orderByComparator) 602 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 603 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last document library folder in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 612 */ 613 public static DLFolder fetchByGroupId_Last(long groupId, 614 OrderByComparator<DLFolder> orderByComparator) { 615 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 616 } 617 618 /** 619 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ?. 620 * 621 * @param folderId the primary key of the current document library 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 document library folder 625 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 626 */ 627 public static DLFolder[] findByGroupId_PrevAndNext(long folderId, 628 long groupId, OrderByComparator<DLFolder> orderByComparator) 629 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 630 return getPersistence() 631 .findByGroupId_PrevAndNext(folderId, groupId, 632 orderByComparator); 633 } 634 635 /** 636 * Returns all the document library folders that the user has permission to view where groupId = ?. 637 * 638 * @param groupId the group ID 639 * @return the matching document library folders that the user has permission to view 640 */ 641 public static List<DLFolder> filterFindByGroupId(long groupId) { 642 return getPersistence().filterFindByGroupId(groupId); 643 } 644 645 /** 646 * Returns a range of all the document library folders that the user has permission to view where groupId = ?. 647 * 648 * <p> 649 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 650 * </p> 651 * 652 * @param groupId the group ID 653 * @param start the lower bound of the range of document library folders 654 * @param end the upper bound of the range of document library folders (not inclusive) 655 * @return the range of matching document library folders that the user has permission to view 656 */ 657 public static List<DLFolder> filterFindByGroupId(long groupId, int start, 658 int end) { 659 return getPersistence().filterFindByGroupId(groupId, start, end); 660 } 661 662 /** 663 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ?. 664 * 665 * <p> 666 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 667 * </p> 668 * 669 * @param groupId the group ID 670 * @param start the lower bound of the range of document library folders 671 * @param end the upper bound of the range of document library folders (not inclusive) 672 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 673 * @return the ordered range of matching document library folders that the user has permission to view 674 */ 675 public static List<DLFolder> filterFindByGroupId(long groupId, int start, 676 int end, OrderByComparator<DLFolder> orderByComparator) { 677 return getPersistence() 678 .filterFindByGroupId(groupId, start, end, orderByComparator); 679 } 680 681 /** 682 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ?. 683 * 684 * @param folderId the primary key of the current document library folder 685 * @param groupId the group ID 686 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 687 * @return the previous, current, and next document library folder 688 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 689 */ 690 public static DLFolder[] filterFindByGroupId_PrevAndNext(long folderId, 691 long groupId, OrderByComparator<DLFolder> orderByComparator) 692 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 693 return getPersistence() 694 .filterFindByGroupId_PrevAndNext(folderId, groupId, 695 orderByComparator); 696 } 697 698 /** 699 * Removes all the document library folders where groupId = ? from the database. 700 * 701 * @param groupId the group ID 702 */ 703 public static void removeByGroupId(long groupId) { 704 getPersistence().removeByGroupId(groupId); 705 } 706 707 /** 708 * Returns the number of document library folders where groupId = ?. 709 * 710 * @param groupId the group ID 711 * @return the number of matching document library folders 712 */ 713 public static int countByGroupId(long groupId) { 714 return getPersistence().countByGroupId(groupId); 715 } 716 717 /** 718 * Returns the number of document library folders that the user has permission to view where groupId = ?. 719 * 720 * @param groupId the group ID 721 * @return the number of matching document library folders that the user has permission to view 722 */ 723 public static int filterCountByGroupId(long groupId) { 724 return getPersistence().filterCountByGroupId(groupId); 725 } 726 727 /** 728 * Returns all the document library folders where companyId = ?. 729 * 730 * @param companyId the company ID 731 * @return the matching document library folders 732 */ 733 public static List<DLFolder> findByCompanyId(long companyId) { 734 return getPersistence().findByCompanyId(companyId); 735 } 736 737 /** 738 * Returns a range of all the document library folders where companyId = ?. 739 * 740 * <p> 741 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 742 * </p> 743 * 744 * @param companyId the company ID 745 * @param start the lower bound of the range of document library folders 746 * @param end the upper bound of the range of document library folders (not inclusive) 747 * @return the range of matching document library folders 748 */ 749 public static List<DLFolder> findByCompanyId(long companyId, int start, 750 int end) { 751 return getPersistence().findByCompanyId(companyId, start, end); 752 } 753 754 /** 755 * Returns an ordered range of all the document library folders where companyId = ?. 756 * 757 * <p> 758 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 759 * </p> 760 * 761 * @param companyId the company ID 762 * @param start the lower bound of the range of document library folders 763 * @param end the upper bound of the range of document library folders (not inclusive) 764 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 765 * @return the ordered range of matching document library folders 766 */ 767 public static List<DLFolder> findByCompanyId(long companyId, int start, 768 int end, OrderByComparator<DLFolder> orderByComparator) { 769 return getPersistence() 770 .findByCompanyId(companyId, start, end, orderByComparator); 771 } 772 773 /** 774 * Returns an ordered range of all the document library folders where companyId = ?. 775 * 776 * <p> 777 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 778 * </p> 779 * 780 * @param companyId the company ID 781 * @param start the lower bound of the range of document library folders 782 * @param end the upper bound of the range of document library folders (not inclusive) 783 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 784 * @param retrieveFromCache whether to retrieve from the finder cache 785 * @return the ordered range of matching document library folders 786 */ 787 public static List<DLFolder> findByCompanyId(long companyId, int start, 788 int end, OrderByComparator<DLFolder> orderByComparator, 789 boolean retrieveFromCache) { 790 return getPersistence() 791 .findByCompanyId(companyId, start, end, orderByComparator, 792 retrieveFromCache); 793 } 794 795 /** 796 * Returns the first document library folder in the ordered set where companyId = ?. 797 * 798 * @param companyId the company ID 799 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 800 * @return the first matching document library folder 801 * @throws NoSuchFolderException if a matching document library folder could not be found 802 */ 803 public static DLFolder findByCompanyId_First(long companyId, 804 OrderByComparator<DLFolder> orderByComparator) 805 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 806 return getPersistence() 807 .findByCompanyId_First(companyId, orderByComparator); 808 } 809 810 /** 811 * Returns the first document library folder in the ordered set where companyId = ?. 812 * 813 * @param companyId the company ID 814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 815 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 816 */ 817 public static DLFolder fetchByCompanyId_First(long companyId, 818 OrderByComparator<DLFolder> orderByComparator) { 819 return getPersistence() 820 .fetchByCompanyId_First(companyId, orderByComparator); 821 } 822 823 /** 824 * Returns the last document library folder in the ordered set where companyId = ?. 825 * 826 * @param companyId the company ID 827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 828 * @return the last matching document library folder 829 * @throws NoSuchFolderException if a matching document library folder could not be found 830 */ 831 public static DLFolder findByCompanyId_Last(long companyId, 832 OrderByComparator<DLFolder> orderByComparator) 833 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 834 return getPersistence() 835 .findByCompanyId_Last(companyId, orderByComparator); 836 } 837 838 /** 839 * Returns the last document library folder in the ordered set where companyId = ?. 840 * 841 * @param companyId the company ID 842 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 843 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 844 */ 845 public static DLFolder fetchByCompanyId_Last(long companyId, 846 OrderByComparator<DLFolder> orderByComparator) { 847 return getPersistence() 848 .fetchByCompanyId_Last(companyId, orderByComparator); 849 } 850 851 /** 852 * Returns the document library folders before and after the current document library folder in the ordered set where companyId = ?. 853 * 854 * @param folderId the primary key of the current document library folder 855 * @param companyId the company ID 856 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 857 * @return the previous, current, and next document library folder 858 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 859 */ 860 public static DLFolder[] findByCompanyId_PrevAndNext(long folderId, 861 long companyId, OrderByComparator<DLFolder> orderByComparator) 862 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 863 return getPersistence() 864 .findByCompanyId_PrevAndNext(folderId, companyId, 865 orderByComparator); 866 } 867 868 /** 869 * Removes all the document library folders where companyId = ? from the database. 870 * 871 * @param companyId the company ID 872 */ 873 public static void removeByCompanyId(long companyId) { 874 getPersistence().removeByCompanyId(companyId); 875 } 876 877 /** 878 * Returns the number of document library folders where companyId = ?. 879 * 880 * @param companyId the company ID 881 * @return the number of matching document library folders 882 */ 883 public static int countByCompanyId(long companyId) { 884 return getPersistence().countByCompanyId(companyId); 885 } 886 887 /** 888 * Returns all the document library folders where repositoryId = ?. 889 * 890 * @param repositoryId the repository ID 891 * @return the matching document library folders 892 */ 893 public static List<DLFolder> findByRepositoryId(long repositoryId) { 894 return getPersistence().findByRepositoryId(repositoryId); 895 } 896 897 /** 898 * Returns a range of all the document library folders where repositoryId = ?. 899 * 900 * <p> 901 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 902 * </p> 903 * 904 * @param repositoryId the repository ID 905 * @param start the lower bound of the range of document library folders 906 * @param end the upper bound of the range of document library folders (not inclusive) 907 * @return the range of matching document library folders 908 */ 909 public static List<DLFolder> findByRepositoryId(long repositoryId, 910 int start, int end) { 911 return getPersistence().findByRepositoryId(repositoryId, start, end); 912 } 913 914 /** 915 * Returns an ordered range of all the document library folders where repositoryId = ?. 916 * 917 * <p> 918 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 919 * </p> 920 * 921 * @param repositoryId the repository ID 922 * @param start the lower bound of the range of document library folders 923 * @param end the upper bound of the range of document library folders (not inclusive) 924 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 925 * @return the ordered range of matching document library folders 926 */ 927 public static List<DLFolder> findByRepositoryId(long repositoryId, 928 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 929 return getPersistence() 930 .findByRepositoryId(repositoryId, start, end, 931 orderByComparator); 932 } 933 934 /** 935 * Returns an ordered range of all the document library folders where repositoryId = ?. 936 * 937 * <p> 938 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 939 * </p> 940 * 941 * @param repositoryId the repository ID 942 * @param start the lower bound of the range of document library folders 943 * @param end the upper bound of the range of document library folders (not inclusive) 944 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 945 * @param retrieveFromCache whether to retrieve from the finder cache 946 * @return the ordered range of matching document library folders 947 */ 948 public static List<DLFolder> findByRepositoryId(long repositoryId, 949 int start, int end, OrderByComparator<DLFolder> orderByComparator, 950 boolean retrieveFromCache) { 951 return getPersistence() 952 .findByRepositoryId(repositoryId, start, end, 953 orderByComparator, retrieveFromCache); 954 } 955 956 /** 957 * Returns the first document library folder in the ordered set where repositoryId = ?. 958 * 959 * @param repositoryId the repository ID 960 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 961 * @return the first matching document library folder 962 * @throws NoSuchFolderException if a matching document library folder could not be found 963 */ 964 public static DLFolder findByRepositoryId_First(long repositoryId, 965 OrderByComparator<DLFolder> orderByComparator) 966 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 967 return getPersistence() 968 .findByRepositoryId_First(repositoryId, orderByComparator); 969 } 970 971 /** 972 * Returns the first document library folder in the ordered set where repositoryId = ?. 973 * 974 * @param repositoryId the repository ID 975 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 976 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 977 */ 978 public static DLFolder fetchByRepositoryId_First(long repositoryId, 979 OrderByComparator<DLFolder> orderByComparator) { 980 return getPersistence() 981 .fetchByRepositoryId_First(repositoryId, orderByComparator); 982 } 983 984 /** 985 * Returns the last document library folder in the ordered set where repositoryId = ?. 986 * 987 * @param repositoryId the repository ID 988 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 989 * @return the last matching document library folder 990 * @throws NoSuchFolderException if a matching document library folder could not be found 991 */ 992 public static DLFolder findByRepositoryId_Last(long repositoryId, 993 OrderByComparator<DLFolder> orderByComparator) 994 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 995 return getPersistence() 996 .findByRepositoryId_Last(repositoryId, orderByComparator); 997 } 998 999 /** 1000 * Returns the last document library folder in the ordered set where repositoryId = ?. 1001 * 1002 * @param repositoryId the repository ID 1003 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1004 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 1005 */ 1006 public static DLFolder fetchByRepositoryId_Last(long repositoryId, 1007 OrderByComparator<DLFolder> orderByComparator) { 1008 return getPersistence() 1009 .fetchByRepositoryId_Last(repositoryId, orderByComparator); 1010 } 1011 1012 /** 1013 * Returns the document library folders before and after the current document library folder in the ordered set where repositoryId = ?. 1014 * 1015 * @param folderId the primary key of the current document library folder 1016 * @param repositoryId the repository ID 1017 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1018 * @return the previous, current, and next document library folder 1019 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 1020 */ 1021 public static DLFolder[] findByRepositoryId_PrevAndNext(long folderId, 1022 long repositoryId, OrderByComparator<DLFolder> orderByComparator) 1023 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1024 return getPersistence() 1025 .findByRepositoryId_PrevAndNext(folderId, repositoryId, 1026 orderByComparator); 1027 } 1028 1029 /** 1030 * Removes all the document library folders where repositoryId = ? from the database. 1031 * 1032 * @param repositoryId the repository ID 1033 */ 1034 public static void removeByRepositoryId(long repositoryId) { 1035 getPersistence().removeByRepositoryId(repositoryId); 1036 } 1037 1038 /** 1039 * Returns the number of document library folders where repositoryId = ?. 1040 * 1041 * @param repositoryId the repository ID 1042 * @return the number of matching document library folders 1043 */ 1044 public static int countByRepositoryId(long repositoryId) { 1045 return getPersistence().countByRepositoryId(repositoryId); 1046 } 1047 1048 /** 1049 * Returns all the document library folders where groupId = ? and parentFolderId = ?. 1050 * 1051 * @param groupId the group ID 1052 * @param parentFolderId the parent folder ID 1053 * @return the matching document library folders 1054 */ 1055 public static List<DLFolder> findByG_P(long groupId, long parentFolderId) { 1056 return getPersistence().findByG_P(groupId, parentFolderId); 1057 } 1058 1059 /** 1060 * Returns a range of all the document library folders where groupId = ? and parentFolderId = ?. 1061 * 1062 * <p> 1063 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1064 * </p> 1065 * 1066 * @param groupId the group ID 1067 * @param parentFolderId the parent folder ID 1068 * @param start the lower bound of the range of document library folders 1069 * @param end the upper bound of the range of document library folders (not inclusive) 1070 * @return the range of matching document library folders 1071 */ 1072 public static List<DLFolder> findByG_P(long groupId, long parentFolderId, 1073 int start, int end) { 1074 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 1075 } 1076 1077 /** 1078 * Returns an ordered range of all the document library folders where groupId = ? and parentFolderId = ?. 1079 * 1080 * <p> 1081 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1082 * </p> 1083 * 1084 * @param groupId the group ID 1085 * @param parentFolderId the parent folder ID 1086 * @param start the lower bound of the range of document library folders 1087 * @param end the upper bound of the range of document library folders (not inclusive) 1088 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1089 * @return the ordered range of matching document library folders 1090 */ 1091 public static List<DLFolder> findByG_P(long groupId, long parentFolderId, 1092 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 1093 return getPersistence() 1094 .findByG_P(groupId, parentFolderId, start, end, 1095 orderByComparator); 1096 } 1097 1098 /** 1099 * Returns an ordered range of all the document library folders where groupId = ? and parentFolderId = ?. 1100 * 1101 * <p> 1102 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1103 * </p> 1104 * 1105 * @param groupId the group ID 1106 * @param parentFolderId the parent folder ID 1107 * @param start the lower bound of the range of document library folders 1108 * @param end the upper bound of the range of document library folders (not inclusive) 1109 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1110 * @param retrieveFromCache whether to retrieve from the finder cache 1111 * @return the ordered range of matching document library folders 1112 */ 1113 public static List<DLFolder> findByG_P(long groupId, long parentFolderId, 1114 int start, int end, OrderByComparator<DLFolder> orderByComparator, 1115 boolean retrieveFromCache) { 1116 return getPersistence() 1117 .findByG_P(groupId, parentFolderId, start, end, 1118 orderByComparator, retrieveFromCache); 1119 } 1120 1121 /** 1122 * Returns the first document library folder in the ordered set where groupId = ? and parentFolderId = ?. 1123 * 1124 * @param groupId the group ID 1125 * @param parentFolderId the parent folder ID 1126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1127 * @return the first matching document library folder 1128 * @throws NoSuchFolderException if a matching document library folder could not be found 1129 */ 1130 public static DLFolder findByG_P_First(long groupId, long parentFolderId, 1131 OrderByComparator<DLFolder> orderByComparator) 1132 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1133 return getPersistence() 1134 .findByG_P_First(groupId, parentFolderId, orderByComparator); 1135 } 1136 1137 /** 1138 * Returns the first document library folder in the ordered set where groupId = ? and parentFolderId = ?. 1139 * 1140 * @param groupId the group ID 1141 * @param parentFolderId the parent folder ID 1142 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1143 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 1144 */ 1145 public static DLFolder fetchByG_P_First(long groupId, long parentFolderId, 1146 OrderByComparator<DLFolder> orderByComparator) { 1147 return getPersistence() 1148 .fetchByG_P_First(groupId, parentFolderId, orderByComparator); 1149 } 1150 1151 /** 1152 * Returns the last document library folder in the ordered set where groupId = ? and parentFolderId = ?. 1153 * 1154 * @param groupId the group ID 1155 * @param parentFolderId the parent folder ID 1156 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1157 * @return the last matching document library folder 1158 * @throws NoSuchFolderException if a matching document library folder could not be found 1159 */ 1160 public static DLFolder findByG_P_Last(long groupId, long parentFolderId, 1161 OrderByComparator<DLFolder> orderByComparator) 1162 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1163 return getPersistence() 1164 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 1165 } 1166 1167 /** 1168 * Returns the last document library folder in the ordered set where groupId = ? and parentFolderId = ?. 1169 * 1170 * @param groupId the group ID 1171 * @param parentFolderId the parent folder ID 1172 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1173 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 1174 */ 1175 public static DLFolder fetchByG_P_Last(long groupId, long parentFolderId, 1176 OrderByComparator<DLFolder> orderByComparator) { 1177 return getPersistence() 1178 .fetchByG_P_Last(groupId, parentFolderId, orderByComparator); 1179 } 1180 1181 /** 1182 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ? and parentFolderId = ?. 1183 * 1184 * @param folderId the primary key of the current document library folder 1185 * @param groupId the group ID 1186 * @param parentFolderId the parent folder ID 1187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1188 * @return the previous, current, and next document library folder 1189 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 1190 */ 1191 public static DLFolder[] findByG_P_PrevAndNext(long folderId, long groupId, 1192 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) 1193 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1194 return getPersistence() 1195 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 1196 orderByComparator); 1197 } 1198 1199 /** 1200 * Returns all the document library folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1201 * 1202 * @param groupId the group ID 1203 * @param parentFolderId the parent folder ID 1204 * @return the matching document library folders that the user has permission to view 1205 */ 1206 public static List<DLFolder> filterFindByG_P(long groupId, 1207 long parentFolderId) { 1208 return getPersistence().filterFindByG_P(groupId, parentFolderId); 1209 } 1210 1211 /** 1212 * Returns a range of all the document library folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1213 * 1214 * <p> 1215 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1216 * </p> 1217 * 1218 * @param groupId the group ID 1219 * @param parentFolderId the parent folder ID 1220 * @param start the lower bound of the range of document library folders 1221 * @param end the upper bound of the range of document library folders (not inclusive) 1222 * @return the range of matching document library folders that the user has permission to view 1223 */ 1224 public static List<DLFolder> filterFindByG_P(long groupId, 1225 long parentFolderId, int start, int end) { 1226 return getPersistence() 1227 .filterFindByG_P(groupId, parentFolderId, start, end); 1228 } 1229 1230 /** 1231 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 1232 * 1233 * <p> 1234 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1235 * </p> 1236 * 1237 * @param groupId the group ID 1238 * @param parentFolderId the parent folder ID 1239 * @param start the lower bound of the range of document library folders 1240 * @param end the upper bound of the range of document library folders (not inclusive) 1241 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1242 * @return the ordered range of matching document library folders that the user has permission to view 1243 */ 1244 public static List<DLFolder> filterFindByG_P(long groupId, 1245 long parentFolderId, int start, int end, 1246 OrderByComparator<DLFolder> orderByComparator) { 1247 return getPersistence() 1248 .filterFindByG_P(groupId, parentFolderId, start, end, 1249 orderByComparator); 1250 } 1251 1252 /** 1253 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1254 * 1255 * @param folderId the primary key of the current document library folder 1256 * @param groupId the group ID 1257 * @param parentFolderId the parent folder ID 1258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1259 * @return the previous, current, and next document library folder 1260 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 1261 */ 1262 public static DLFolder[] filterFindByG_P_PrevAndNext(long folderId, 1263 long groupId, long parentFolderId, 1264 OrderByComparator<DLFolder> orderByComparator) 1265 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1266 return getPersistence() 1267 .filterFindByG_P_PrevAndNext(folderId, groupId, 1268 parentFolderId, orderByComparator); 1269 } 1270 1271 /** 1272 * Removes all the document library folders where groupId = ? and parentFolderId = ? from the database. 1273 * 1274 * @param groupId the group ID 1275 * @param parentFolderId the parent folder ID 1276 */ 1277 public static void removeByG_P(long groupId, long parentFolderId) { 1278 getPersistence().removeByG_P(groupId, parentFolderId); 1279 } 1280 1281 /** 1282 * Returns the number of document library folders where groupId = ? and parentFolderId = ?. 1283 * 1284 * @param groupId the group ID 1285 * @param parentFolderId the parent folder ID 1286 * @return the number of matching document library folders 1287 */ 1288 public static int countByG_P(long groupId, long parentFolderId) { 1289 return getPersistence().countByG_P(groupId, parentFolderId); 1290 } 1291 1292 /** 1293 * Returns the number of document library folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1294 * 1295 * @param groupId the group ID 1296 * @param parentFolderId the parent folder ID 1297 * @return the number of matching document library folders that the user has permission to view 1298 */ 1299 public static int filterCountByG_P(long groupId, long parentFolderId) { 1300 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1301 } 1302 1303 /** 1304 * Returns all the document library folders where companyId = ? and status ≠ ?. 1305 * 1306 * @param companyId the company ID 1307 * @param status the status 1308 * @return the matching document library folders 1309 */ 1310 public static List<DLFolder> findByC_NotS(long companyId, int status) { 1311 return getPersistence().findByC_NotS(companyId, status); 1312 } 1313 1314 /** 1315 * Returns a range of all the document library folders where companyId = ? and status ≠ ?. 1316 * 1317 * <p> 1318 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1319 * </p> 1320 * 1321 * @param companyId the company ID 1322 * @param status the status 1323 * @param start the lower bound of the range of document library folders 1324 * @param end the upper bound of the range of document library folders (not inclusive) 1325 * @return the range of matching document library folders 1326 */ 1327 public static List<DLFolder> findByC_NotS(long companyId, int status, 1328 int start, int end) { 1329 return getPersistence().findByC_NotS(companyId, status, start, end); 1330 } 1331 1332 /** 1333 * Returns an ordered range of all the document library folders where companyId = ? 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 companyId the company ID 1340 * @param status the status 1341 * @param start the lower bound of the range of document library folders 1342 * @param end the upper bound of the range of document library folders (not inclusive) 1343 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1344 * @return the ordered range of matching document library folders 1345 */ 1346 public static List<DLFolder> findByC_NotS(long companyId, int status, 1347 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 1348 return getPersistence() 1349 .findByC_NotS(companyId, status, start, end, 1350 orderByComparator); 1351 } 1352 1353 /** 1354 * Returns an ordered range of all the document library folders where companyId = ? and status ≠ ?. 1355 * 1356 * <p> 1357 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1358 * </p> 1359 * 1360 * @param companyId the company ID 1361 * @param status the status 1362 * @param start the lower bound of the range of document library folders 1363 * @param end the upper bound of the range of document library folders (not inclusive) 1364 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1365 * @param retrieveFromCache whether to retrieve from the finder cache 1366 * @return the ordered range of matching document library folders 1367 */ 1368 public static List<DLFolder> findByC_NotS(long companyId, int status, 1369 int start, int end, OrderByComparator<DLFolder> orderByComparator, 1370 boolean retrieveFromCache) { 1371 return getPersistence() 1372 .findByC_NotS(companyId, status, start, end, 1373 orderByComparator, retrieveFromCache); 1374 } 1375 1376 /** 1377 * Returns the first document library folder in the ordered set where companyId = ? and status ≠ ?. 1378 * 1379 * @param companyId the company 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 document library folder 1383 * @throws NoSuchFolderException if a matching document library folder could not be found 1384 */ 1385 public static DLFolder findByC_NotS_First(long companyId, int status, 1386 OrderByComparator<DLFolder> orderByComparator) 1387 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1388 return getPersistence() 1389 .findByC_NotS_First(companyId, status, orderByComparator); 1390 } 1391 1392 /** 1393 * Returns the first document library folder in the ordered set where companyId = ? and status ≠ ?. 1394 * 1395 * @param companyId the company ID 1396 * @param status the status 1397 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1398 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 1399 */ 1400 public static DLFolder fetchByC_NotS_First(long companyId, int status, 1401 OrderByComparator<DLFolder> orderByComparator) { 1402 return getPersistence() 1403 .fetchByC_NotS_First(companyId, status, orderByComparator); 1404 } 1405 1406 /** 1407 * Returns the last document library folder in the ordered set where companyId = ? and status ≠ ?. 1408 * 1409 * @param companyId the company ID 1410 * @param status the status 1411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1412 * @return the last matching document library folder 1413 * @throws NoSuchFolderException if a matching document library folder could not be found 1414 */ 1415 public static DLFolder findByC_NotS_Last(long companyId, int status, 1416 OrderByComparator<DLFolder> orderByComparator) 1417 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1418 return getPersistence() 1419 .findByC_NotS_Last(companyId, status, orderByComparator); 1420 } 1421 1422 /** 1423 * Returns the last document library folder in the ordered set where companyId = ? and status ≠ ?. 1424 * 1425 * @param companyId the company ID 1426 * @param status the status 1427 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1428 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 1429 */ 1430 public static DLFolder fetchByC_NotS_Last(long companyId, int status, 1431 OrderByComparator<DLFolder> orderByComparator) { 1432 return getPersistence() 1433 .fetchByC_NotS_Last(companyId, status, orderByComparator); 1434 } 1435 1436 /** 1437 * Returns the document library folders before and after the current document library folder in the ordered set where companyId = ? and status ≠ ?. 1438 * 1439 * @param folderId the primary key of the current document library folder 1440 * @param companyId the company ID 1441 * @param status the status 1442 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1443 * @return the previous, current, and next document library folder 1444 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 1445 */ 1446 public static DLFolder[] findByC_NotS_PrevAndNext(long folderId, 1447 long companyId, int status, 1448 OrderByComparator<DLFolder> orderByComparator) 1449 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1450 return getPersistence() 1451 .findByC_NotS_PrevAndNext(folderId, companyId, status, 1452 orderByComparator); 1453 } 1454 1455 /** 1456 * Removes all the document library folders where companyId = ? and status ≠ ? from the database. 1457 * 1458 * @param companyId the company ID 1459 * @param status the status 1460 */ 1461 public static void removeByC_NotS(long companyId, int status) { 1462 getPersistence().removeByC_NotS(companyId, status); 1463 } 1464 1465 /** 1466 * Returns the number of document library folders where companyId = ? and status ≠ ?. 1467 * 1468 * @param companyId the company ID 1469 * @param status the status 1470 * @return the number of matching document library folders 1471 */ 1472 public static int countByC_NotS(long companyId, int status) { 1473 return getPersistence().countByC_NotS(companyId, status); 1474 } 1475 1476 /** 1477 * Returns the document library folder where repositoryId = ? and mountPoint = ? or throws a {@link NoSuchFolderException} if it could not be found. 1478 * 1479 * @param repositoryId the repository ID 1480 * @param mountPoint the mount point 1481 * @return the matching document library folder 1482 * @throws NoSuchFolderException if a matching document library folder could not be found 1483 */ 1484 public static DLFolder findByR_M(long repositoryId, boolean mountPoint) 1485 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1486 return getPersistence().findByR_M(repositoryId, mountPoint); 1487 } 1488 1489 /** 1490 * Returns the document library folder where repositoryId = ? and mountPoint = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1491 * 1492 * @param repositoryId the repository ID 1493 * @param mountPoint the mount point 1494 * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found 1495 */ 1496 public static DLFolder fetchByR_M(long repositoryId, boolean mountPoint) { 1497 return getPersistence().fetchByR_M(repositoryId, mountPoint); 1498 } 1499 1500 /** 1501 * Returns the document library folder where repositoryId = ? and mountPoint = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1502 * 1503 * @param repositoryId the repository ID 1504 * @param mountPoint the mount point 1505 * @param retrieveFromCache whether to retrieve from the finder cache 1506 * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found 1507 */ 1508 public static DLFolder fetchByR_M(long repositoryId, boolean mountPoint, 1509 boolean retrieveFromCache) { 1510 return getPersistence() 1511 .fetchByR_M(repositoryId, mountPoint, retrieveFromCache); 1512 } 1513 1514 /** 1515 * Removes the document library folder where repositoryId = ? and mountPoint = ? from the database. 1516 * 1517 * @param repositoryId the repository ID 1518 * @param mountPoint the mount point 1519 * @return the document library folder that was removed 1520 */ 1521 public static DLFolder removeByR_M(long repositoryId, boolean mountPoint) 1522 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1523 return getPersistence().removeByR_M(repositoryId, mountPoint); 1524 } 1525 1526 /** 1527 * Returns the number of document library folders where repositoryId = ? and mountPoint = ?. 1528 * 1529 * @param repositoryId the repository ID 1530 * @param mountPoint the mount point 1531 * @return the number of matching document library folders 1532 */ 1533 public static int countByR_M(long repositoryId, boolean mountPoint) { 1534 return getPersistence().countByR_M(repositoryId, mountPoint); 1535 } 1536 1537 /** 1538 * Returns all the document library folders where repositoryId = ? and parentFolderId = ?. 1539 * 1540 * @param repositoryId the repository ID 1541 * @param parentFolderId the parent folder ID 1542 * @return the matching document library folders 1543 */ 1544 public static List<DLFolder> findByR_P(long repositoryId, 1545 long parentFolderId) { 1546 return getPersistence().findByR_P(repositoryId, parentFolderId); 1547 } 1548 1549 /** 1550 * Returns a range of all the document library folders where repositoryId = ? and parentFolderId = ?. 1551 * 1552 * <p> 1553 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1554 * </p> 1555 * 1556 * @param repositoryId the repository ID 1557 * @param parentFolderId the parent folder ID 1558 * @param start the lower bound of the range of document library folders 1559 * @param end the upper bound of the range of document library folders (not inclusive) 1560 * @return the range of matching document library folders 1561 */ 1562 public static List<DLFolder> findByR_P(long repositoryId, 1563 long parentFolderId, int start, int end) { 1564 return getPersistence() 1565 .findByR_P(repositoryId, parentFolderId, start, end); 1566 } 1567 1568 /** 1569 * Returns an ordered range of all the document library folders where repositoryId = ? and parentFolderId = ?. 1570 * 1571 * <p> 1572 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1573 * </p> 1574 * 1575 * @param repositoryId the repository ID 1576 * @param parentFolderId the parent folder ID 1577 * @param start the lower bound of the range of document library folders 1578 * @param end the upper bound of the range of document library folders (not inclusive) 1579 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1580 * @return the ordered range of matching document library folders 1581 */ 1582 public static List<DLFolder> findByR_P(long repositoryId, 1583 long parentFolderId, int start, int end, 1584 OrderByComparator<DLFolder> orderByComparator) { 1585 return getPersistence() 1586 .findByR_P(repositoryId, parentFolderId, start, end, 1587 orderByComparator); 1588 } 1589 1590 /** 1591 * Returns an ordered range of all the document library folders where repositoryId = ? and parentFolderId = ?. 1592 * 1593 * <p> 1594 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1595 * </p> 1596 * 1597 * @param repositoryId the repository ID 1598 * @param parentFolderId the parent folder ID 1599 * @param start the lower bound of the range of document library folders 1600 * @param end the upper bound of the range of document library folders (not inclusive) 1601 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1602 * @param retrieveFromCache whether to retrieve from the finder cache 1603 * @return the ordered range of matching document library folders 1604 */ 1605 public static List<DLFolder> findByR_P(long repositoryId, 1606 long parentFolderId, int start, int end, 1607 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 1608 return getPersistence() 1609 .findByR_P(repositoryId, parentFolderId, start, end, 1610 orderByComparator, retrieveFromCache); 1611 } 1612 1613 /** 1614 * Returns the first document library folder in the ordered set where repositoryId = ? and parentFolderId = ?. 1615 * 1616 * @param repositoryId the repository ID 1617 * @param parentFolderId the parent folder ID 1618 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1619 * @return the first matching document library folder 1620 * @throws NoSuchFolderException if a matching document library folder could not be found 1621 */ 1622 public static DLFolder findByR_P_First(long repositoryId, 1623 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) 1624 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1625 return getPersistence() 1626 .findByR_P_First(repositoryId, parentFolderId, 1627 orderByComparator); 1628 } 1629 1630 /** 1631 * Returns the first document library folder in the ordered set where repositoryId = ? and parentFolderId = ?. 1632 * 1633 * @param repositoryId the repository ID 1634 * @param parentFolderId the parent folder ID 1635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1636 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 1637 */ 1638 public static DLFolder fetchByR_P_First(long repositoryId, 1639 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) { 1640 return getPersistence() 1641 .fetchByR_P_First(repositoryId, parentFolderId, 1642 orderByComparator); 1643 } 1644 1645 /** 1646 * Returns the last document library folder in the ordered set where repositoryId = ? and parentFolderId = ?. 1647 * 1648 * @param repositoryId the repository ID 1649 * @param parentFolderId the parent folder ID 1650 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1651 * @return the last matching document library folder 1652 * @throws NoSuchFolderException if a matching document library folder could not be found 1653 */ 1654 public static DLFolder findByR_P_Last(long repositoryId, 1655 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) 1656 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1657 return getPersistence() 1658 .findByR_P_Last(repositoryId, parentFolderId, 1659 orderByComparator); 1660 } 1661 1662 /** 1663 * Returns the last document library folder in the ordered set where repositoryId = ? and parentFolderId = ?. 1664 * 1665 * @param repositoryId the repository ID 1666 * @param parentFolderId the parent folder ID 1667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1668 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 1669 */ 1670 public static DLFolder fetchByR_P_Last(long repositoryId, 1671 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) { 1672 return getPersistence() 1673 .fetchByR_P_Last(repositoryId, parentFolderId, 1674 orderByComparator); 1675 } 1676 1677 /** 1678 * Returns the document library folders before and after the current document library folder in the ordered set where repositoryId = ? and parentFolderId = ?. 1679 * 1680 * @param folderId the primary key of the current document library folder 1681 * @param repositoryId the repository ID 1682 * @param parentFolderId the parent folder ID 1683 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1684 * @return the previous, current, and next document library folder 1685 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 1686 */ 1687 public static DLFolder[] findByR_P_PrevAndNext(long folderId, 1688 long repositoryId, long parentFolderId, 1689 OrderByComparator<DLFolder> orderByComparator) 1690 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1691 return getPersistence() 1692 .findByR_P_PrevAndNext(folderId, repositoryId, 1693 parentFolderId, orderByComparator); 1694 } 1695 1696 /** 1697 * Removes all the document library folders where repositoryId = ? and parentFolderId = ? from the database. 1698 * 1699 * @param repositoryId the repository ID 1700 * @param parentFolderId the parent folder ID 1701 */ 1702 public static void removeByR_P(long repositoryId, long parentFolderId) { 1703 getPersistence().removeByR_P(repositoryId, parentFolderId); 1704 } 1705 1706 /** 1707 * Returns the number of document library folders where repositoryId = ? and parentFolderId = ?. 1708 * 1709 * @param repositoryId the repository ID 1710 * @param parentFolderId the parent folder ID 1711 * @return the number of matching document library folders 1712 */ 1713 public static int countByR_P(long repositoryId, long parentFolderId) { 1714 return getPersistence().countByR_P(repositoryId, parentFolderId); 1715 } 1716 1717 /** 1718 * Returns all the document library folders where parentFolderId = ? and name = ?. 1719 * 1720 * @param parentFolderId the parent folder ID 1721 * @param name the name 1722 * @return the matching document library folders 1723 */ 1724 public static List<DLFolder> findByP_N(long parentFolderId, 1725 java.lang.String name) { 1726 return getPersistence().findByP_N(parentFolderId, name); 1727 } 1728 1729 /** 1730 * Returns a range of all the document library folders where parentFolderId = ? and name = ?. 1731 * 1732 * <p> 1733 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1734 * </p> 1735 * 1736 * @param parentFolderId the parent folder ID 1737 * @param name the name 1738 * @param start the lower bound of the range of document library folders 1739 * @param end the upper bound of the range of document library folders (not inclusive) 1740 * @return the range of matching document library folders 1741 */ 1742 public static List<DLFolder> findByP_N(long parentFolderId, 1743 java.lang.String name, int start, int end) { 1744 return getPersistence().findByP_N(parentFolderId, name, start, end); 1745 } 1746 1747 /** 1748 * Returns an ordered range of all the document library folders where parentFolderId = ? and name = ?. 1749 * 1750 * <p> 1751 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1752 * </p> 1753 * 1754 * @param parentFolderId the parent folder ID 1755 * @param name the name 1756 * @param start the lower bound of the range of document library folders 1757 * @param end the upper bound of the range of document library folders (not inclusive) 1758 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1759 * @return the ordered range of matching document library folders 1760 */ 1761 public static List<DLFolder> findByP_N(long parentFolderId, 1762 java.lang.String name, int start, int end, 1763 OrderByComparator<DLFolder> orderByComparator) { 1764 return getPersistence() 1765 .findByP_N(parentFolderId, name, start, end, 1766 orderByComparator); 1767 } 1768 1769 /** 1770 * Returns an ordered range of all the document library folders where parentFolderId = ? and name = ?. 1771 * 1772 * <p> 1773 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1774 * </p> 1775 * 1776 * @param parentFolderId the parent folder ID 1777 * @param name the name 1778 * @param start the lower bound of the range of document library folders 1779 * @param end the upper bound of the range of document library folders (not inclusive) 1780 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1781 * @param retrieveFromCache whether to retrieve from the finder cache 1782 * @return the ordered range of matching document library folders 1783 */ 1784 public static List<DLFolder> findByP_N(long parentFolderId, 1785 java.lang.String name, int start, int end, 1786 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 1787 return getPersistence() 1788 .findByP_N(parentFolderId, name, start, end, 1789 orderByComparator, retrieveFromCache); 1790 } 1791 1792 /** 1793 * Returns the first document library folder in the ordered set where parentFolderId = ? and name = ?. 1794 * 1795 * @param parentFolderId the parent folder ID 1796 * @param name the name 1797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1798 * @return the first matching document library folder 1799 * @throws NoSuchFolderException if a matching document library folder could not be found 1800 */ 1801 public static DLFolder findByP_N_First(long parentFolderId, 1802 java.lang.String name, OrderByComparator<DLFolder> orderByComparator) 1803 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1804 return getPersistence() 1805 .findByP_N_First(parentFolderId, name, orderByComparator); 1806 } 1807 1808 /** 1809 * Returns the first document library folder in the ordered set where parentFolderId = ? and name = ?. 1810 * 1811 * @param parentFolderId the parent folder ID 1812 * @param name the name 1813 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1814 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 1815 */ 1816 public static DLFolder fetchByP_N_First(long parentFolderId, 1817 java.lang.String name, OrderByComparator<DLFolder> orderByComparator) { 1818 return getPersistence() 1819 .fetchByP_N_First(parentFolderId, name, orderByComparator); 1820 } 1821 1822 /** 1823 * Returns the last document library folder in the ordered set where parentFolderId = ? and name = ?. 1824 * 1825 * @param parentFolderId the parent folder ID 1826 * @param name the name 1827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1828 * @return the last matching document library folder 1829 * @throws NoSuchFolderException if a matching document library folder could not be found 1830 */ 1831 public static DLFolder findByP_N_Last(long parentFolderId, 1832 java.lang.String name, OrderByComparator<DLFolder> orderByComparator) 1833 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1834 return getPersistence() 1835 .findByP_N_Last(parentFolderId, name, orderByComparator); 1836 } 1837 1838 /** 1839 * Returns the last document library folder in the ordered set where parentFolderId = ? and name = ?. 1840 * 1841 * @param parentFolderId the parent folder ID 1842 * @param name the name 1843 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1844 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 1845 */ 1846 public static DLFolder fetchByP_N_Last(long parentFolderId, 1847 java.lang.String name, OrderByComparator<DLFolder> orderByComparator) { 1848 return getPersistence() 1849 .fetchByP_N_Last(parentFolderId, name, orderByComparator); 1850 } 1851 1852 /** 1853 * Returns the document library folders before and after the current document library folder in the ordered set where parentFolderId = ? and name = ?. 1854 * 1855 * @param folderId the primary key of the current document library folder 1856 * @param parentFolderId the parent folder ID 1857 * @param name the name 1858 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1859 * @return the previous, current, and next document library folder 1860 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 1861 */ 1862 public static DLFolder[] findByP_N_PrevAndNext(long folderId, 1863 long parentFolderId, java.lang.String name, 1864 OrderByComparator<DLFolder> orderByComparator) 1865 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1866 return getPersistence() 1867 .findByP_N_PrevAndNext(folderId, parentFolderId, name, 1868 orderByComparator); 1869 } 1870 1871 /** 1872 * Removes all the document library folders where parentFolderId = ? and name = ? from the database. 1873 * 1874 * @param parentFolderId the parent folder ID 1875 * @param name the name 1876 */ 1877 public static void removeByP_N(long parentFolderId, java.lang.String name) { 1878 getPersistence().removeByP_N(parentFolderId, name); 1879 } 1880 1881 /** 1882 * Returns the number of document library folders where parentFolderId = ? and name = ?. 1883 * 1884 * @param parentFolderId the parent folder ID 1885 * @param name the name 1886 * @return the number of matching document library folders 1887 */ 1888 public static int countByP_N(long parentFolderId, java.lang.String name) { 1889 return getPersistence().countByP_N(parentFolderId, name); 1890 } 1891 1892 /** 1893 * Returns all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ?. 1894 * 1895 * @param groupId the group ID 1896 * @param mountPoint the mount point 1897 * @param parentFolderId the parent folder ID 1898 * @return the matching document library folders 1899 */ 1900 public static List<DLFolder> findByG_M_P(long groupId, boolean mountPoint, 1901 long parentFolderId) { 1902 return getPersistence().findByG_M_P(groupId, mountPoint, parentFolderId); 1903 } 1904 1905 /** 1906 * Returns a range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ?. 1907 * 1908 * <p> 1909 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1910 * </p> 1911 * 1912 * @param groupId the group ID 1913 * @param mountPoint the mount point 1914 * @param parentFolderId the parent folder ID 1915 * @param start the lower bound of the range of document library folders 1916 * @param end the upper bound of the range of document library folders (not inclusive) 1917 * @return the range of matching document library folders 1918 */ 1919 public static List<DLFolder> findByG_M_P(long groupId, boolean mountPoint, 1920 long parentFolderId, int start, int end) { 1921 return getPersistence() 1922 .findByG_M_P(groupId, mountPoint, parentFolderId, start, end); 1923 } 1924 1925 /** 1926 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ?. 1927 * 1928 * <p> 1929 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1930 * </p> 1931 * 1932 * @param groupId the group ID 1933 * @param mountPoint the mount point 1934 * @param parentFolderId the parent folder ID 1935 * @param start the lower bound of the range of document library folders 1936 * @param end the upper bound of the range of document library folders (not inclusive) 1937 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1938 * @return the ordered range of matching document library folders 1939 */ 1940 public static List<DLFolder> findByG_M_P(long groupId, boolean mountPoint, 1941 long parentFolderId, int start, int end, 1942 OrderByComparator<DLFolder> orderByComparator) { 1943 return getPersistence() 1944 .findByG_M_P(groupId, mountPoint, parentFolderId, start, 1945 end, orderByComparator); 1946 } 1947 1948 /** 1949 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ?. 1950 * 1951 * <p> 1952 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1953 * </p> 1954 * 1955 * @param groupId the group ID 1956 * @param mountPoint the mount point 1957 * @param parentFolderId the parent folder ID 1958 * @param start the lower bound of the range of document library folders 1959 * @param end the upper bound of the range of document library folders (not inclusive) 1960 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1961 * @param retrieveFromCache whether to retrieve from the finder cache 1962 * @return the ordered range of matching document library folders 1963 */ 1964 public static List<DLFolder> findByG_M_P(long groupId, boolean mountPoint, 1965 long parentFolderId, int start, int end, 1966 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 1967 return getPersistence() 1968 .findByG_M_P(groupId, mountPoint, parentFolderId, start, 1969 end, orderByComparator, retrieveFromCache); 1970 } 1971 1972 /** 1973 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ?. 1974 * 1975 * @param groupId the group ID 1976 * @param mountPoint the mount point 1977 * @param parentFolderId the parent folder ID 1978 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1979 * @return the first matching document library folder 1980 * @throws NoSuchFolderException if a matching document library folder could not be found 1981 */ 1982 public static DLFolder findByG_M_P_First(long groupId, boolean mountPoint, 1983 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) 1984 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 1985 return getPersistence() 1986 .findByG_M_P_First(groupId, mountPoint, parentFolderId, 1987 orderByComparator); 1988 } 1989 1990 /** 1991 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ?. 1992 * 1993 * @param groupId the group ID 1994 * @param mountPoint the mount point 1995 * @param parentFolderId the parent folder ID 1996 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1997 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 1998 */ 1999 public static DLFolder fetchByG_M_P_First(long groupId, boolean mountPoint, 2000 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) { 2001 return getPersistence() 2002 .fetchByG_M_P_First(groupId, mountPoint, parentFolderId, 2003 orderByComparator); 2004 } 2005 2006 /** 2007 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ?. 2008 * 2009 * @param groupId the group ID 2010 * @param mountPoint the mount point 2011 * @param parentFolderId the parent folder ID 2012 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2013 * @return the last matching document library folder 2014 * @throws NoSuchFolderException if a matching document library folder could not be found 2015 */ 2016 public static DLFolder findByG_M_P_Last(long groupId, boolean mountPoint, 2017 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) 2018 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2019 return getPersistence() 2020 .findByG_M_P_Last(groupId, mountPoint, parentFolderId, 2021 orderByComparator); 2022 } 2023 2024 /** 2025 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ?. 2026 * 2027 * @param groupId the group ID 2028 * @param mountPoint the mount point 2029 * @param parentFolderId the parent folder ID 2030 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2031 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 2032 */ 2033 public static DLFolder fetchByG_M_P_Last(long groupId, boolean mountPoint, 2034 long parentFolderId, OrderByComparator<DLFolder> orderByComparator) { 2035 return getPersistence() 2036 .fetchByG_M_P_Last(groupId, mountPoint, parentFolderId, 2037 orderByComparator); 2038 } 2039 2040 /** 2041 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ?. 2042 * 2043 * @param folderId the primary key of the current document library folder 2044 * @param groupId the group ID 2045 * @param mountPoint the mount point 2046 * @param parentFolderId the parent folder ID 2047 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2048 * @return the previous, current, and next document library folder 2049 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 2050 */ 2051 public static DLFolder[] findByG_M_P_PrevAndNext(long folderId, 2052 long groupId, boolean mountPoint, long parentFolderId, 2053 OrderByComparator<DLFolder> orderByComparator) 2054 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2055 return getPersistence() 2056 .findByG_M_P_PrevAndNext(folderId, groupId, mountPoint, 2057 parentFolderId, orderByComparator); 2058 } 2059 2060 /** 2061 * Returns all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ?. 2062 * 2063 * @param groupId the group ID 2064 * @param mountPoint the mount point 2065 * @param parentFolderId the parent folder ID 2066 * @return the matching document library folders that the user has permission to view 2067 */ 2068 public static List<DLFolder> filterFindByG_M_P(long groupId, 2069 boolean mountPoint, long parentFolderId) { 2070 return getPersistence() 2071 .filterFindByG_M_P(groupId, mountPoint, parentFolderId); 2072 } 2073 2074 /** 2075 * Returns a range of all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ?. 2076 * 2077 * <p> 2078 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2079 * </p> 2080 * 2081 * @param groupId the group ID 2082 * @param mountPoint the mount point 2083 * @param parentFolderId the parent folder ID 2084 * @param start the lower bound of the range of document library folders 2085 * @param end the upper bound of the range of document library folders (not inclusive) 2086 * @return the range of matching document library folders that the user has permission to view 2087 */ 2088 public static List<DLFolder> filterFindByG_M_P(long groupId, 2089 boolean mountPoint, long parentFolderId, int start, int end) { 2090 return getPersistence() 2091 .filterFindByG_M_P(groupId, mountPoint, parentFolderId, 2092 start, end); 2093 } 2094 2095 /** 2096 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ? and mountPoint = ? and parentFolderId = ?. 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID 2103 * @param mountPoint the mount point 2104 * @param parentFolderId the parent folder ID 2105 * @param start the lower bound of the range of document library folders 2106 * @param end the upper bound of the range of document library folders (not inclusive) 2107 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2108 * @return the ordered range of matching document library folders that the user has permission to view 2109 */ 2110 public static List<DLFolder> filterFindByG_M_P(long groupId, 2111 boolean mountPoint, long parentFolderId, int start, int end, 2112 OrderByComparator<DLFolder> orderByComparator) { 2113 return getPersistence() 2114 .filterFindByG_M_P(groupId, mountPoint, parentFolderId, 2115 start, end, orderByComparator); 2116 } 2117 2118 /** 2119 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ?. 2120 * 2121 * @param folderId the primary key of the current document library folder 2122 * @param groupId the group ID 2123 * @param mountPoint the mount point 2124 * @param parentFolderId the parent folder ID 2125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2126 * @return the previous, current, and next document library folder 2127 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 2128 */ 2129 public static DLFolder[] filterFindByG_M_P_PrevAndNext(long folderId, 2130 long groupId, boolean mountPoint, long parentFolderId, 2131 OrderByComparator<DLFolder> orderByComparator) 2132 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2133 return getPersistence() 2134 .filterFindByG_M_P_PrevAndNext(folderId, groupId, 2135 mountPoint, parentFolderId, orderByComparator); 2136 } 2137 2138 /** 2139 * Removes all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? from the database. 2140 * 2141 * @param groupId the group ID 2142 * @param mountPoint the mount point 2143 * @param parentFolderId the parent folder ID 2144 */ 2145 public static void removeByG_M_P(long groupId, boolean mountPoint, 2146 long parentFolderId) { 2147 getPersistence().removeByG_M_P(groupId, mountPoint, parentFolderId); 2148 } 2149 2150 /** 2151 * Returns the number of document library folders where groupId = ? and mountPoint = ? and parentFolderId = ?. 2152 * 2153 * @param groupId the group ID 2154 * @param mountPoint the mount point 2155 * @param parentFolderId the parent folder ID 2156 * @return the number of matching document library folders 2157 */ 2158 public static int countByG_M_P(long groupId, boolean mountPoint, 2159 long parentFolderId) { 2160 return getPersistence().countByG_M_P(groupId, mountPoint, parentFolderId); 2161 } 2162 2163 /** 2164 * Returns the number of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ?. 2165 * 2166 * @param groupId the group ID 2167 * @param mountPoint the mount point 2168 * @param parentFolderId the parent folder ID 2169 * @return the number of matching document library folders that the user has permission to view 2170 */ 2171 public static int filterCountByG_M_P(long groupId, boolean mountPoint, 2172 long parentFolderId) { 2173 return getPersistence() 2174 .filterCountByG_M_P(groupId, mountPoint, parentFolderId); 2175 } 2176 2177 /** 2178 * Returns the document library folder where groupId = ? and parentFolderId = ? and name = ? or throws a {@link NoSuchFolderException} if it could not be found. 2179 * 2180 * @param groupId the group ID 2181 * @param parentFolderId the parent folder ID 2182 * @param name the name 2183 * @return the matching document library folder 2184 * @throws NoSuchFolderException if a matching document library folder could not be found 2185 */ 2186 public static DLFolder findByG_P_N(long groupId, long parentFolderId, 2187 java.lang.String name) 2188 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2189 return getPersistence().findByG_P_N(groupId, parentFolderId, name); 2190 } 2191 2192 /** 2193 * Returns the document library folder where groupId = ? and parentFolderId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2194 * 2195 * @param groupId the group ID 2196 * @param parentFolderId the parent folder ID 2197 * @param name the name 2198 * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found 2199 */ 2200 public static DLFolder fetchByG_P_N(long groupId, long parentFolderId, 2201 java.lang.String name) { 2202 return getPersistence().fetchByG_P_N(groupId, parentFolderId, name); 2203 } 2204 2205 /** 2206 * Returns the document library folder where groupId = ? and parentFolderId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2207 * 2208 * @param groupId the group ID 2209 * @param parentFolderId the parent folder ID 2210 * @param name the name 2211 * @param retrieveFromCache whether to retrieve from the finder cache 2212 * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found 2213 */ 2214 public static DLFolder fetchByG_P_N(long groupId, long parentFolderId, 2215 java.lang.String name, boolean retrieveFromCache) { 2216 return getPersistence() 2217 .fetchByG_P_N(groupId, parentFolderId, name, 2218 retrieveFromCache); 2219 } 2220 2221 /** 2222 * Removes the document library folder where groupId = ? and parentFolderId = ? and name = ? from the database. 2223 * 2224 * @param groupId the group ID 2225 * @param parentFolderId the parent folder ID 2226 * @param name the name 2227 * @return the document library folder that was removed 2228 */ 2229 public static DLFolder removeByG_P_N(long groupId, long parentFolderId, 2230 java.lang.String name) 2231 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2232 return getPersistence().removeByG_P_N(groupId, parentFolderId, name); 2233 } 2234 2235 /** 2236 * Returns the number of document library folders where groupId = ? and parentFolderId = ? and name = ?. 2237 * 2238 * @param groupId the group ID 2239 * @param parentFolderId the parent folder ID 2240 * @param name the name 2241 * @return the number of matching document library folders 2242 */ 2243 public static int countByG_P_N(long groupId, long parentFolderId, 2244 java.lang.String name) { 2245 return getPersistence().countByG_P_N(groupId, parentFolderId, name); 2246 } 2247 2248 /** 2249 * Returns all the document library folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2250 * 2251 * @param folderId the folder ID 2252 * @param companyId the company ID 2253 * @param parentFolderId the parent folder ID 2254 * @param status the status 2255 * @return the matching document library folders 2256 */ 2257 public static List<DLFolder> findByF_C_P_NotS(long folderId, 2258 long companyId, long parentFolderId, int status) { 2259 return getPersistence() 2260 .findByF_C_P_NotS(folderId, companyId, parentFolderId, status); 2261 } 2262 2263 /** 2264 * Returns a range of all the document library folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2265 * 2266 * <p> 2267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2268 * </p> 2269 * 2270 * @param folderId the folder ID 2271 * @param companyId the company ID 2272 * @param parentFolderId the parent folder ID 2273 * @param status the status 2274 * @param start the lower bound of the range of document library folders 2275 * @param end the upper bound of the range of document library folders (not inclusive) 2276 * @return the range of matching document library folders 2277 */ 2278 public static List<DLFolder> findByF_C_P_NotS(long folderId, 2279 long companyId, long parentFolderId, int status, int start, int end) { 2280 return getPersistence() 2281 .findByF_C_P_NotS(folderId, companyId, parentFolderId, 2282 status, start, end); 2283 } 2284 2285 /** 2286 * Returns an ordered range of all the document library folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2287 * 2288 * <p> 2289 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2290 * </p> 2291 * 2292 * @param folderId the folder ID 2293 * @param companyId the company ID 2294 * @param parentFolderId the parent folder ID 2295 * @param status the status 2296 * @param start the lower bound of the range of document library folders 2297 * @param end the upper bound of the range of document library folders (not inclusive) 2298 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2299 * @return the ordered range of matching document library folders 2300 */ 2301 public static List<DLFolder> findByF_C_P_NotS(long folderId, 2302 long companyId, long parentFolderId, int status, int start, int end, 2303 OrderByComparator<DLFolder> orderByComparator) { 2304 return getPersistence() 2305 .findByF_C_P_NotS(folderId, companyId, parentFolderId, 2306 status, start, end, orderByComparator); 2307 } 2308 2309 /** 2310 * Returns an ordered range of all the document library folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2311 * 2312 * <p> 2313 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2314 * </p> 2315 * 2316 * @param folderId the folder ID 2317 * @param companyId the company ID 2318 * @param parentFolderId the parent folder ID 2319 * @param status the status 2320 * @param start the lower bound of the range of document library folders 2321 * @param end the upper bound of the range of document library folders (not inclusive) 2322 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2323 * @param retrieveFromCache whether to retrieve from the finder cache 2324 * @return the ordered range of matching document library folders 2325 */ 2326 public static List<DLFolder> findByF_C_P_NotS(long folderId, 2327 long companyId, long parentFolderId, int status, int start, int end, 2328 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 2329 return getPersistence() 2330 .findByF_C_P_NotS(folderId, companyId, parentFolderId, 2331 status, start, end, orderByComparator, retrieveFromCache); 2332 } 2333 2334 /** 2335 * Returns the first document library folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2336 * 2337 * @param folderId the folder ID 2338 * @param companyId the company ID 2339 * @param parentFolderId the parent folder ID 2340 * @param status the status 2341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2342 * @return the first matching document library folder 2343 * @throws NoSuchFolderException if a matching document library folder could not be found 2344 */ 2345 public static DLFolder findByF_C_P_NotS_First(long folderId, 2346 long companyId, long parentFolderId, int status, 2347 OrderByComparator<DLFolder> orderByComparator) 2348 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2349 return getPersistence() 2350 .findByF_C_P_NotS_First(folderId, companyId, parentFolderId, 2351 status, orderByComparator); 2352 } 2353 2354 /** 2355 * Returns the first document library folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2356 * 2357 * @param folderId the folder ID 2358 * @param companyId the company ID 2359 * @param parentFolderId the parent folder ID 2360 * @param status the status 2361 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2362 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 2363 */ 2364 public static DLFolder fetchByF_C_P_NotS_First(long folderId, 2365 long companyId, long parentFolderId, int status, 2366 OrderByComparator<DLFolder> orderByComparator) { 2367 return getPersistence() 2368 .fetchByF_C_P_NotS_First(folderId, companyId, 2369 parentFolderId, status, orderByComparator); 2370 } 2371 2372 /** 2373 * Returns the last document library folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2374 * 2375 * @param folderId the folder ID 2376 * @param companyId the company ID 2377 * @param parentFolderId the parent folder ID 2378 * @param status the status 2379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2380 * @return the last matching document library folder 2381 * @throws NoSuchFolderException if a matching document library folder could not be found 2382 */ 2383 public static DLFolder findByF_C_P_NotS_Last(long folderId, long companyId, 2384 long parentFolderId, int status, 2385 OrderByComparator<DLFolder> orderByComparator) 2386 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2387 return getPersistence() 2388 .findByF_C_P_NotS_Last(folderId, companyId, parentFolderId, 2389 status, orderByComparator); 2390 } 2391 2392 /** 2393 * Returns the last document library folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2394 * 2395 * @param folderId the folder ID 2396 * @param companyId the company ID 2397 * @param parentFolderId the parent folder ID 2398 * @param status the status 2399 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2400 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 2401 */ 2402 public static DLFolder fetchByF_C_P_NotS_Last(long folderId, 2403 long companyId, long parentFolderId, int status, 2404 OrderByComparator<DLFolder> orderByComparator) { 2405 return getPersistence() 2406 .fetchByF_C_P_NotS_Last(folderId, companyId, parentFolderId, 2407 status, orderByComparator); 2408 } 2409 2410 /** 2411 * Removes all the document library folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ? from the database. 2412 * 2413 * @param folderId the folder ID 2414 * @param companyId the company ID 2415 * @param parentFolderId the parent folder ID 2416 * @param status the status 2417 */ 2418 public static void removeByF_C_P_NotS(long folderId, long companyId, 2419 long parentFolderId, int status) { 2420 getPersistence() 2421 .removeByF_C_P_NotS(folderId, companyId, parentFolderId, status); 2422 } 2423 2424 /** 2425 * Returns the number of document library folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 2426 * 2427 * @param folderId the folder ID 2428 * @param companyId the company ID 2429 * @param parentFolderId the parent folder ID 2430 * @param status the status 2431 * @return the number of matching document library folders 2432 */ 2433 public static int countByF_C_P_NotS(long folderId, long companyId, 2434 long parentFolderId, int status) { 2435 return getPersistence() 2436 .countByF_C_P_NotS(folderId, companyId, parentFolderId, 2437 status); 2438 } 2439 2440 /** 2441 * Returns all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2442 * 2443 * @param groupId the group ID 2444 * @param mountPoint the mount point 2445 * @param parentFolderId the parent folder ID 2446 * @param hidden the hidden 2447 * @return the matching document library folders 2448 */ 2449 public static List<DLFolder> findByG_M_P_H(long groupId, 2450 boolean mountPoint, long parentFolderId, boolean hidden) { 2451 return getPersistence() 2452 .findByG_M_P_H(groupId, mountPoint, parentFolderId, hidden); 2453 } 2454 2455 /** 2456 * Returns a range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2457 * 2458 * <p> 2459 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2460 * </p> 2461 * 2462 * @param groupId the group ID 2463 * @param mountPoint the mount point 2464 * @param parentFolderId the parent folder ID 2465 * @param hidden the hidden 2466 * @param start the lower bound of the range of document library folders 2467 * @param end the upper bound of the range of document library folders (not inclusive) 2468 * @return the range of matching document library folders 2469 */ 2470 public static List<DLFolder> findByG_M_P_H(long groupId, 2471 boolean mountPoint, long parentFolderId, boolean hidden, int start, 2472 int end) { 2473 return getPersistence() 2474 .findByG_M_P_H(groupId, mountPoint, parentFolderId, hidden, 2475 start, end); 2476 } 2477 2478 /** 2479 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2480 * 2481 * <p> 2482 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2483 * </p> 2484 * 2485 * @param groupId the group ID 2486 * @param mountPoint the mount point 2487 * @param parentFolderId the parent folder ID 2488 * @param hidden the hidden 2489 * @param start the lower bound of the range of document library folders 2490 * @param end the upper bound of the range of document library folders (not inclusive) 2491 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2492 * @return the ordered range of matching document library folders 2493 */ 2494 public static List<DLFolder> findByG_M_P_H(long groupId, 2495 boolean mountPoint, long parentFolderId, boolean hidden, int start, 2496 int end, OrderByComparator<DLFolder> orderByComparator) { 2497 return getPersistence() 2498 .findByG_M_P_H(groupId, mountPoint, parentFolderId, hidden, 2499 start, end, orderByComparator); 2500 } 2501 2502 /** 2503 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2504 * 2505 * <p> 2506 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2507 * </p> 2508 * 2509 * @param groupId the group ID 2510 * @param mountPoint the mount point 2511 * @param parentFolderId the parent folder ID 2512 * @param hidden the hidden 2513 * @param start the lower bound of the range of document library folders 2514 * @param end the upper bound of the range of document library folders (not inclusive) 2515 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2516 * @param retrieveFromCache whether to retrieve from the finder cache 2517 * @return the ordered range of matching document library folders 2518 */ 2519 public static List<DLFolder> findByG_M_P_H(long groupId, 2520 boolean mountPoint, long parentFolderId, boolean hidden, int start, 2521 int end, OrderByComparator<DLFolder> orderByComparator, 2522 boolean retrieveFromCache) { 2523 return getPersistence() 2524 .findByG_M_P_H(groupId, mountPoint, parentFolderId, hidden, 2525 start, end, orderByComparator, retrieveFromCache); 2526 } 2527 2528 /** 2529 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2530 * 2531 * @param groupId the group ID 2532 * @param mountPoint the mount point 2533 * @param parentFolderId the parent folder ID 2534 * @param hidden the hidden 2535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2536 * @return the first matching document library folder 2537 * @throws NoSuchFolderException if a matching document library folder could not be found 2538 */ 2539 public static DLFolder findByG_M_P_H_First(long groupId, 2540 boolean mountPoint, long parentFolderId, boolean hidden, 2541 OrderByComparator<DLFolder> orderByComparator) 2542 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2543 return getPersistence() 2544 .findByG_M_P_H_First(groupId, mountPoint, parentFolderId, 2545 hidden, orderByComparator); 2546 } 2547 2548 /** 2549 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2550 * 2551 * @param groupId the group ID 2552 * @param mountPoint the mount point 2553 * @param parentFolderId the parent folder ID 2554 * @param hidden the hidden 2555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2556 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 2557 */ 2558 public static DLFolder fetchByG_M_P_H_First(long groupId, 2559 boolean mountPoint, long parentFolderId, boolean hidden, 2560 OrderByComparator<DLFolder> orderByComparator) { 2561 return getPersistence() 2562 .fetchByG_M_P_H_First(groupId, mountPoint, parentFolderId, 2563 hidden, orderByComparator); 2564 } 2565 2566 /** 2567 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2568 * 2569 * @param groupId the group ID 2570 * @param mountPoint the mount point 2571 * @param parentFolderId the parent folder ID 2572 * @param hidden the hidden 2573 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2574 * @return the last matching document library folder 2575 * @throws NoSuchFolderException if a matching document library folder could not be found 2576 */ 2577 public static DLFolder findByG_M_P_H_Last(long groupId, boolean mountPoint, 2578 long parentFolderId, boolean hidden, 2579 OrderByComparator<DLFolder> orderByComparator) 2580 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2581 return getPersistence() 2582 .findByG_M_P_H_Last(groupId, mountPoint, parentFolderId, 2583 hidden, orderByComparator); 2584 } 2585 2586 /** 2587 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2588 * 2589 * @param groupId the group ID 2590 * @param mountPoint the mount point 2591 * @param parentFolderId the parent folder ID 2592 * @param hidden the hidden 2593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2594 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 2595 */ 2596 public static DLFolder fetchByG_M_P_H_Last(long groupId, 2597 boolean mountPoint, long parentFolderId, boolean hidden, 2598 OrderByComparator<DLFolder> orderByComparator) { 2599 return getPersistence() 2600 .fetchByG_M_P_H_Last(groupId, mountPoint, parentFolderId, 2601 hidden, orderByComparator); 2602 } 2603 2604 /** 2605 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2606 * 2607 * @param folderId the primary key of the current document library folder 2608 * @param groupId the group ID 2609 * @param mountPoint the mount point 2610 * @param parentFolderId the parent folder ID 2611 * @param hidden the hidden 2612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2613 * @return the previous, current, and next document library folder 2614 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 2615 */ 2616 public static DLFolder[] findByG_M_P_H_PrevAndNext(long folderId, 2617 long groupId, boolean mountPoint, long parentFolderId, boolean hidden, 2618 OrderByComparator<DLFolder> orderByComparator) 2619 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2620 return getPersistence() 2621 .findByG_M_P_H_PrevAndNext(folderId, groupId, mountPoint, 2622 parentFolderId, hidden, orderByComparator); 2623 } 2624 2625 /** 2626 * Returns all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2627 * 2628 * @param groupId the group ID 2629 * @param mountPoint the mount point 2630 * @param parentFolderId the parent folder ID 2631 * @param hidden the hidden 2632 * @return the matching document library folders that the user has permission to view 2633 */ 2634 public static List<DLFolder> filterFindByG_M_P_H(long groupId, 2635 boolean mountPoint, long parentFolderId, boolean hidden) { 2636 return getPersistence() 2637 .filterFindByG_M_P_H(groupId, mountPoint, parentFolderId, 2638 hidden); 2639 } 2640 2641 /** 2642 * Returns a range of all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2643 * 2644 * <p> 2645 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2646 * </p> 2647 * 2648 * @param groupId the group ID 2649 * @param mountPoint the mount point 2650 * @param parentFolderId the parent folder ID 2651 * @param hidden the hidden 2652 * @param start the lower bound of the range of document library folders 2653 * @param end the upper bound of the range of document library folders (not inclusive) 2654 * @return the range of matching document library folders that the user has permission to view 2655 */ 2656 public static List<DLFolder> filterFindByG_M_P_H(long groupId, 2657 boolean mountPoint, long parentFolderId, boolean hidden, int start, 2658 int end) { 2659 return getPersistence() 2660 .filterFindByG_M_P_H(groupId, mountPoint, parentFolderId, 2661 hidden, start, end); 2662 } 2663 2664 /** 2665 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2666 * 2667 * <p> 2668 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2669 * </p> 2670 * 2671 * @param groupId the group ID 2672 * @param mountPoint the mount point 2673 * @param parentFolderId the parent folder ID 2674 * @param hidden the hidden 2675 * @param start the lower bound of the range of document library folders 2676 * @param end the upper bound of the range of document library folders (not inclusive) 2677 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2678 * @return the ordered range of matching document library folders that the user has permission to view 2679 */ 2680 public static List<DLFolder> filterFindByG_M_P_H(long groupId, 2681 boolean mountPoint, long parentFolderId, boolean hidden, int start, 2682 int end, OrderByComparator<DLFolder> orderByComparator) { 2683 return getPersistence() 2684 .filterFindByG_M_P_H(groupId, mountPoint, parentFolderId, 2685 hidden, start, end, orderByComparator); 2686 } 2687 2688 /** 2689 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2690 * 2691 * @param folderId the primary key of the current document library folder 2692 * @param groupId the group ID 2693 * @param mountPoint the mount point 2694 * @param parentFolderId the parent folder ID 2695 * @param hidden the hidden 2696 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2697 * @return the previous, current, and next document library folder 2698 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 2699 */ 2700 public static DLFolder[] filterFindByG_M_P_H_PrevAndNext(long folderId, 2701 long groupId, boolean mountPoint, long parentFolderId, boolean hidden, 2702 OrderByComparator<DLFolder> orderByComparator) 2703 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2704 return getPersistence() 2705 .filterFindByG_M_P_H_PrevAndNext(folderId, groupId, 2706 mountPoint, parentFolderId, hidden, orderByComparator); 2707 } 2708 2709 /** 2710 * Removes all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? from the database. 2711 * 2712 * @param groupId the group ID 2713 * @param mountPoint the mount point 2714 * @param parentFolderId the parent folder ID 2715 * @param hidden the hidden 2716 */ 2717 public static void removeByG_M_P_H(long groupId, boolean mountPoint, 2718 long parentFolderId, boolean hidden) { 2719 getPersistence() 2720 .removeByG_M_P_H(groupId, mountPoint, parentFolderId, hidden); 2721 } 2722 2723 /** 2724 * Returns the number of document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2725 * 2726 * @param groupId the group ID 2727 * @param mountPoint the mount point 2728 * @param parentFolderId the parent folder ID 2729 * @param hidden the hidden 2730 * @return the number of matching document library folders 2731 */ 2732 public static int countByG_M_P_H(long groupId, boolean mountPoint, 2733 long parentFolderId, boolean hidden) { 2734 return getPersistence() 2735 .countByG_M_P_H(groupId, mountPoint, parentFolderId, hidden); 2736 } 2737 2738 /** 2739 * Returns the number of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ?. 2740 * 2741 * @param groupId the group ID 2742 * @param mountPoint the mount point 2743 * @param parentFolderId the parent folder ID 2744 * @param hidden the hidden 2745 * @return the number of matching document library folders that the user has permission to view 2746 */ 2747 public static int filterCountByG_M_P_H(long groupId, boolean mountPoint, 2748 long parentFolderId, boolean hidden) { 2749 return getPersistence() 2750 .filterCountByG_M_P_H(groupId, mountPoint, parentFolderId, 2751 hidden); 2752 } 2753 2754 /** 2755 * Returns all the document library folders where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2756 * 2757 * @param groupId the group ID 2758 * @param mountPoint the mount point 2759 * @param treePath the tree path 2760 * @param hidden the hidden 2761 * @return the matching document library folders 2762 */ 2763 public static List<DLFolder> findByG_M_T_H(long groupId, 2764 boolean mountPoint, java.lang.String treePath, boolean hidden) { 2765 return getPersistence() 2766 .findByG_M_T_H(groupId, mountPoint, treePath, hidden); 2767 } 2768 2769 /** 2770 * Returns a range of all the document library folders where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2771 * 2772 * <p> 2773 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2774 * </p> 2775 * 2776 * @param groupId the group ID 2777 * @param mountPoint the mount point 2778 * @param treePath the tree path 2779 * @param hidden the hidden 2780 * @param start the lower bound of the range of document library folders 2781 * @param end the upper bound of the range of document library folders (not inclusive) 2782 * @return the range of matching document library folders 2783 */ 2784 public static List<DLFolder> findByG_M_T_H(long groupId, 2785 boolean mountPoint, java.lang.String treePath, boolean hidden, 2786 int start, int end) { 2787 return getPersistence() 2788 .findByG_M_T_H(groupId, mountPoint, treePath, hidden, start, 2789 end); 2790 } 2791 2792 /** 2793 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2794 * 2795 * <p> 2796 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2797 * </p> 2798 * 2799 * @param groupId the group ID 2800 * @param mountPoint the mount point 2801 * @param treePath the tree path 2802 * @param hidden the hidden 2803 * @param start the lower bound of the range of document library folders 2804 * @param end the upper bound of the range of document library folders (not inclusive) 2805 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2806 * @return the ordered range of matching document library folders 2807 */ 2808 public static List<DLFolder> findByG_M_T_H(long groupId, 2809 boolean mountPoint, java.lang.String treePath, boolean hidden, 2810 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 2811 return getPersistence() 2812 .findByG_M_T_H(groupId, mountPoint, treePath, hidden, start, 2813 end, orderByComparator); 2814 } 2815 2816 /** 2817 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2818 * 2819 * <p> 2820 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2821 * </p> 2822 * 2823 * @param groupId the group ID 2824 * @param mountPoint the mount point 2825 * @param treePath the tree path 2826 * @param hidden the hidden 2827 * @param start the lower bound of the range of document library folders 2828 * @param end the upper bound of the range of document library folders (not inclusive) 2829 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2830 * @param retrieveFromCache whether to retrieve from the finder cache 2831 * @return the ordered range of matching document library folders 2832 */ 2833 public static List<DLFolder> findByG_M_T_H(long groupId, 2834 boolean mountPoint, java.lang.String treePath, boolean hidden, 2835 int start, int end, OrderByComparator<DLFolder> orderByComparator, 2836 boolean retrieveFromCache) { 2837 return getPersistence() 2838 .findByG_M_T_H(groupId, mountPoint, treePath, hidden, start, 2839 end, orderByComparator, retrieveFromCache); 2840 } 2841 2842 /** 2843 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2844 * 2845 * @param groupId the group ID 2846 * @param mountPoint the mount point 2847 * @param treePath the tree path 2848 * @param hidden the hidden 2849 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2850 * @return the first matching document library folder 2851 * @throws NoSuchFolderException if a matching document library folder could not be found 2852 */ 2853 public static DLFolder findByG_M_T_H_First(long groupId, 2854 boolean mountPoint, java.lang.String treePath, boolean hidden, 2855 OrderByComparator<DLFolder> orderByComparator) 2856 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2857 return getPersistence() 2858 .findByG_M_T_H_First(groupId, mountPoint, treePath, hidden, 2859 orderByComparator); 2860 } 2861 2862 /** 2863 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2864 * 2865 * @param groupId the group ID 2866 * @param mountPoint the mount point 2867 * @param treePath the tree path 2868 * @param hidden the hidden 2869 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2870 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 2871 */ 2872 public static DLFolder fetchByG_M_T_H_First(long groupId, 2873 boolean mountPoint, java.lang.String treePath, boolean hidden, 2874 OrderByComparator<DLFolder> orderByComparator) { 2875 return getPersistence() 2876 .fetchByG_M_T_H_First(groupId, mountPoint, treePath, hidden, 2877 orderByComparator); 2878 } 2879 2880 /** 2881 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2882 * 2883 * @param groupId the group ID 2884 * @param mountPoint the mount point 2885 * @param treePath the tree path 2886 * @param hidden the hidden 2887 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2888 * @return the last matching document library folder 2889 * @throws NoSuchFolderException if a matching document library folder could not be found 2890 */ 2891 public static DLFolder findByG_M_T_H_Last(long groupId, boolean mountPoint, 2892 java.lang.String treePath, boolean hidden, 2893 OrderByComparator<DLFolder> orderByComparator) 2894 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2895 return getPersistence() 2896 .findByG_M_T_H_Last(groupId, mountPoint, treePath, hidden, 2897 orderByComparator); 2898 } 2899 2900 /** 2901 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2902 * 2903 * @param groupId the group ID 2904 * @param mountPoint the mount point 2905 * @param treePath the tree path 2906 * @param hidden the hidden 2907 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2908 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 2909 */ 2910 public static DLFolder fetchByG_M_T_H_Last(long groupId, 2911 boolean mountPoint, java.lang.String treePath, boolean hidden, 2912 OrderByComparator<DLFolder> orderByComparator) { 2913 return getPersistence() 2914 .fetchByG_M_T_H_Last(groupId, mountPoint, treePath, hidden, 2915 orderByComparator); 2916 } 2917 2918 /** 2919 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2920 * 2921 * @param folderId the primary key of the current document library folder 2922 * @param groupId the group ID 2923 * @param mountPoint the mount point 2924 * @param treePath the tree path 2925 * @param hidden the hidden 2926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2927 * @return the previous, current, and next document library folder 2928 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 2929 */ 2930 public static DLFolder[] findByG_M_T_H_PrevAndNext(long folderId, 2931 long groupId, boolean mountPoint, java.lang.String treePath, 2932 boolean hidden, OrderByComparator<DLFolder> orderByComparator) 2933 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 2934 return getPersistence() 2935 .findByG_M_T_H_PrevAndNext(folderId, groupId, mountPoint, 2936 treePath, hidden, orderByComparator); 2937 } 2938 2939 /** 2940 * Returns all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2941 * 2942 * @param groupId the group ID 2943 * @param mountPoint the mount point 2944 * @param treePath the tree path 2945 * @param hidden the hidden 2946 * @return the matching document library folders that the user has permission to view 2947 */ 2948 public static List<DLFolder> filterFindByG_M_T_H(long groupId, 2949 boolean mountPoint, java.lang.String treePath, boolean hidden) { 2950 return getPersistence() 2951 .filterFindByG_M_T_H(groupId, mountPoint, treePath, hidden); 2952 } 2953 2954 /** 2955 * Returns a range of all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2956 * 2957 * <p> 2958 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2959 * </p> 2960 * 2961 * @param groupId the group ID 2962 * @param mountPoint the mount point 2963 * @param treePath the tree path 2964 * @param hidden the hidden 2965 * @param start the lower bound of the range of document library folders 2966 * @param end the upper bound of the range of document library folders (not inclusive) 2967 * @return the range of matching document library folders that the user has permission to view 2968 */ 2969 public static List<DLFolder> filterFindByG_M_T_H(long groupId, 2970 boolean mountPoint, java.lang.String treePath, boolean hidden, 2971 int start, int end) { 2972 return getPersistence() 2973 .filterFindByG_M_T_H(groupId, mountPoint, treePath, hidden, 2974 start, end); 2975 } 2976 2977 /** 2978 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 2979 * 2980 * <p> 2981 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2982 * </p> 2983 * 2984 * @param groupId the group ID 2985 * @param mountPoint the mount point 2986 * @param treePath the tree path 2987 * @param hidden the hidden 2988 * @param start the lower bound of the range of document library folders 2989 * @param end the upper bound of the range of document library folders (not inclusive) 2990 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2991 * @return the ordered range of matching document library folders that the user has permission to view 2992 */ 2993 public static List<DLFolder> filterFindByG_M_T_H(long groupId, 2994 boolean mountPoint, java.lang.String treePath, boolean hidden, 2995 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 2996 return getPersistence() 2997 .filterFindByG_M_T_H(groupId, mountPoint, treePath, hidden, 2998 start, end, orderByComparator); 2999 } 3000 3001 /** 3002 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 3003 * 3004 * @param folderId the primary key of the current document library folder 3005 * @param groupId the group ID 3006 * @param mountPoint the mount point 3007 * @param treePath the tree path 3008 * @param hidden the hidden 3009 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3010 * @return the previous, current, and next document library folder 3011 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3012 */ 3013 public static DLFolder[] filterFindByG_M_T_H_PrevAndNext(long folderId, 3014 long groupId, boolean mountPoint, java.lang.String treePath, 3015 boolean hidden, OrderByComparator<DLFolder> orderByComparator) 3016 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3017 return getPersistence() 3018 .filterFindByG_M_T_H_PrevAndNext(folderId, groupId, 3019 mountPoint, treePath, hidden, orderByComparator); 3020 } 3021 3022 /** 3023 * Removes all the document library folders where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ? from the database. 3024 * 3025 * @param groupId the group ID 3026 * @param mountPoint the mount point 3027 * @param treePath the tree path 3028 * @param hidden the hidden 3029 */ 3030 public static void removeByG_M_T_H(long groupId, boolean mountPoint, 3031 java.lang.String treePath, boolean hidden) { 3032 getPersistence().removeByG_M_T_H(groupId, mountPoint, treePath, hidden); 3033 } 3034 3035 /** 3036 * Returns the number of document library folders where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 3037 * 3038 * @param groupId the group ID 3039 * @param mountPoint the mount point 3040 * @param treePath the tree path 3041 * @param hidden the hidden 3042 * @return the number of matching document library folders 3043 */ 3044 public static int countByG_M_T_H(long groupId, boolean mountPoint, 3045 java.lang.String treePath, boolean hidden) { 3046 return getPersistence() 3047 .countByG_M_T_H(groupId, mountPoint, treePath, hidden); 3048 } 3049 3050 /** 3051 * Returns the number of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and treePath LIKE ? and hidden = ?. 3052 * 3053 * @param groupId the group ID 3054 * @param mountPoint the mount point 3055 * @param treePath the tree path 3056 * @param hidden the hidden 3057 * @return the number of matching document library folders that the user has permission to view 3058 */ 3059 public static int filterCountByG_M_T_H(long groupId, boolean mountPoint, 3060 java.lang.String treePath, boolean hidden) { 3061 return getPersistence() 3062 .filterCountByG_M_T_H(groupId, mountPoint, treePath, hidden); 3063 } 3064 3065 /** 3066 * Returns all the document library folders where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3067 * 3068 * @param groupId the group ID 3069 * @param parentFolderId the parent folder ID 3070 * @param hidden the hidden 3071 * @param status the status 3072 * @return the matching document library folders 3073 */ 3074 public static List<DLFolder> findByG_P_H_S(long groupId, 3075 long parentFolderId, boolean hidden, int status) { 3076 return getPersistence() 3077 .findByG_P_H_S(groupId, parentFolderId, hidden, status); 3078 } 3079 3080 /** 3081 * Returns a range of all the document library folders where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3082 * 3083 * <p> 3084 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3085 * </p> 3086 * 3087 * @param groupId the group ID 3088 * @param parentFolderId the parent folder ID 3089 * @param hidden the hidden 3090 * @param status the status 3091 * @param start the lower bound of the range of document library folders 3092 * @param end the upper bound of the range of document library folders (not inclusive) 3093 * @return the range of matching document library folders 3094 */ 3095 public static List<DLFolder> findByG_P_H_S(long groupId, 3096 long parentFolderId, boolean hidden, int status, int start, int end) { 3097 return getPersistence() 3098 .findByG_P_H_S(groupId, parentFolderId, hidden, status, 3099 start, end); 3100 } 3101 3102 /** 3103 * Returns an ordered range of all the document library folders where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3104 * 3105 * <p> 3106 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3107 * </p> 3108 * 3109 * @param groupId the group ID 3110 * @param parentFolderId the parent folder ID 3111 * @param hidden the hidden 3112 * @param status the status 3113 * @param start the lower bound of the range of document library folders 3114 * @param end the upper bound of the range of document library folders (not inclusive) 3115 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3116 * @return the ordered range of matching document library folders 3117 */ 3118 public static List<DLFolder> findByG_P_H_S(long groupId, 3119 long parentFolderId, boolean hidden, int status, int start, int end, 3120 OrderByComparator<DLFolder> orderByComparator) { 3121 return getPersistence() 3122 .findByG_P_H_S(groupId, parentFolderId, hidden, status, 3123 start, end, orderByComparator); 3124 } 3125 3126 /** 3127 * Returns an ordered range of all the document library folders where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3128 * 3129 * <p> 3130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3131 * </p> 3132 * 3133 * @param groupId the group ID 3134 * @param parentFolderId the parent folder ID 3135 * @param hidden the hidden 3136 * @param status the status 3137 * @param start the lower bound of the range of document library folders 3138 * @param end the upper bound of the range of document library folders (not inclusive) 3139 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3140 * @param retrieveFromCache whether to retrieve from the finder cache 3141 * @return the ordered range of matching document library folders 3142 */ 3143 public static List<DLFolder> findByG_P_H_S(long groupId, 3144 long parentFolderId, boolean hidden, int status, int start, int end, 3145 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 3146 return getPersistence() 3147 .findByG_P_H_S(groupId, parentFolderId, hidden, status, 3148 start, end, orderByComparator, retrieveFromCache); 3149 } 3150 3151 /** 3152 * Returns the first document library folder in the ordered set where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3153 * 3154 * @param groupId the group ID 3155 * @param parentFolderId the parent folder ID 3156 * @param hidden the hidden 3157 * @param status the status 3158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3159 * @return the first matching document library folder 3160 * @throws NoSuchFolderException if a matching document library folder could not be found 3161 */ 3162 public static DLFolder findByG_P_H_S_First(long groupId, 3163 long parentFolderId, boolean hidden, int status, 3164 OrderByComparator<DLFolder> orderByComparator) 3165 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3166 return getPersistence() 3167 .findByG_P_H_S_First(groupId, parentFolderId, hidden, 3168 status, orderByComparator); 3169 } 3170 3171 /** 3172 * Returns the first document library folder in the ordered set where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3173 * 3174 * @param groupId the group ID 3175 * @param parentFolderId the parent folder ID 3176 * @param hidden the hidden 3177 * @param status the status 3178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3179 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 3180 */ 3181 public static DLFolder fetchByG_P_H_S_First(long groupId, 3182 long parentFolderId, boolean hidden, int status, 3183 OrderByComparator<DLFolder> orderByComparator) { 3184 return getPersistence() 3185 .fetchByG_P_H_S_First(groupId, parentFolderId, hidden, 3186 status, orderByComparator); 3187 } 3188 3189 /** 3190 * Returns the last document library folder in the ordered set where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3191 * 3192 * @param groupId the group ID 3193 * @param parentFolderId the parent folder ID 3194 * @param hidden the hidden 3195 * @param status the status 3196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3197 * @return the last matching document library folder 3198 * @throws NoSuchFolderException if a matching document library folder could not be found 3199 */ 3200 public static DLFolder findByG_P_H_S_Last(long groupId, 3201 long parentFolderId, boolean hidden, int status, 3202 OrderByComparator<DLFolder> orderByComparator) 3203 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3204 return getPersistence() 3205 .findByG_P_H_S_Last(groupId, parentFolderId, hidden, status, 3206 orderByComparator); 3207 } 3208 3209 /** 3210 * Returns the last document library folder in the ordered set where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3211 * 3212 * @param groupId the group ID 3213 * @param parentFolderId the parent folder ID 3214 * @param hidden the hidden 3215 * @param status the status 3216 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3217 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 3218 */ 3219 public static DLFolder fetchByG_P_H_S_Last(long groupId, 3220 long parentFolderId, boolean hidden, int status, 3221 OrderByComparator<DLFolder> orderByComparator) { 3222 return getPersistence() 3223 .fetchByG_P_H_S_Last(groupId, parentFolderId, hidden, 3224 status, orderByComparator); 3225 } 3226 3227 /** 3228 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3229 * 3230 * @param folderId the primary key of the current document library folder 3231 * @param groupId the group ID 3232 * @param parentFolderId the parent folder ID 3233 * @param hidden the hidden 3234 * @param status the status 3235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3236 * @return the previous, current, and next document library folder 3237 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3238 */ 3239 public static DLFolder[] findByG_P_H_S_PrevAndNext(long folderId, 3240 long groupId, long parentFolderId, boolean hidden, int status, 3241 OrderByComparator<DLFolder> orderByComparator) 3242 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3243 return getPersistence() 3244 .findByG_P_H_S_PrevAndNext(folderId, groupId, 3245 parentFolderId, hidden, status, orderByComparator); 3246 } 3247 3248 /** 3249 * Returns all the document library folders that the user has permission to view where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3250 * 3251 * @param groupId the group ID 3252 * @param parentFolderId the parent folder ID 3253 * @param hidden the hidden 3254 * @param status the status 3255 * @return the matching document library folders that the user has permission to view 3256 */ 3257 public static List<DLFolder> filterFindByG_P_H_S(long groupId, 3258 long parentFolderId, boolean hidden, int status) { 3259 return getPersistence() 3260 .filterFindByG_P_H_S(groupId, parentFolderId, hidden, status); 3261 } 3262 3263 /** 3264 * Returns a range of all the document library folders that the user has permission to view where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3265 * 3266 * <p> 3267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3268 * </p> 3269 * 3270 * @param groupId the group ID 3271 * @param parentFolderId the parent folder ID 3272 * @param hidden the hidden 3273 * @param status the status 3274 * @param start the lower bound of the range of document library folders 3275 * @param end the upper bound of the range of document library folders (not inclusive) 3276 * @return the range of matching document library folders that the user has permission to view 3277 */ 3278 public static List<DLFolder> filterFindByG_P_H_S(long groupId, 3279 long parentFolderId, boolean hidden, int status, int start, int end) { 3280 return getPersistence() 3281 .filterFindByG_P_H_S(groupId, parentFolderId, hidden, 3282 status, start, end); 3283 } 3284 3285 /** 3286 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3287 * 3288 * <p> 3289 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3290 * </p> 3291 * 3292 * @param groupId the group ID 3293 * @param parentFolderId the parent folder ID 3294 * @param hidden the hidden 3295 * @param status the status 3296 * @param start the lower bound of the range of document library folders 3297 * @param end the upper bound of the range of document library folders (not inclusive) 3298 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3299 * @return the ordered range of matching document library folders that the user has permission to view 3300 */ 3301 public static List<DLFolder> filterFindByG_P_H_S(long groupId, 3302 long parentFolderId, boolean hidden, int status, int start, int end, 3303 OrderByComparator<DLFolder> orderByComparator) { 3304 return getPersistence() 3305 .filterFindByG_P_H_S(groupId, parentFolderId, hidden, 3306 status, start, end, orderByComparator); 3307 } 3308 3309 /** 3310 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3311 * 3312 * @param folderId the primary key of the current document library folder 3313 * @param groupId the group ID 3314 * @param parentFolderId the parent folder ID 3315 * @param hidden the hidden 3316 * @param status the status 3317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3318 * @return the previous, current, and next document library folder 3319 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3320 */ 3321 public static DLFolder[] filterFindByG_P_H_S_PrevAndNext(long folderId, 3322 long groupId, long parentFolderId, boolean hidden, int status, 3323 OrderByComparator<DLFolder> orderByComparator) 3324 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3325 return getPersistence() 3326 .filterFindByG_P_H_S_PrevAndNext(folderId, groupId, 3327 parentFolderId, hidden, status, orderByComparator); 3328 } 3329 3330 /** 3331 * Removes all the document library folders where groupId = ? and parentFolderId = ? and hidden = ? and status = ? from the database. 3332 * 3333 * @param groupId the group ID 3334 * @param parentFolderId the parent folder ID 3335 * @param hidden the hidden 3336 * @param status the status 3337 */ 3338 public static void removeByG_P_H_S(long groupId, long parentFolderId, 3339 boolean hidden, int status) { 3340 getPersistence().removeByG_P_H_S(groupId, parentFolderId, hidden, status); 3341 } 3342 3343 /** 3344 * Returns the number of document library folders where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3345 * 3346 * @param groupId the group ID 3347 * @param parentFolderId the parent folder ID 3348 * @param hidden the hidden 3349 * @param status the status 3350 * @return the number of matching document library folders 3351 */ 3352 public static int countByG_P_H_S(long groupId, long parentFolderId, 3353 boolean hidden, int status) { 3354 return getPersistence() 3355 .countByG_P_H_S(groupId, parentFolderId, hidden, status); 3356 } 3357 3358 /** 3359 * Returns the number of document library folders that the user has permission to view where groupId = ? and parentFolderId = ? and hidden = ? and status = ?. 3360 * 3361 * @param groupId the group ID 3362 * @param parentFolderId the parent folder ID 3363 * @param hidden the hidden 3364 * @param status the status 3365 * @return the number of matching document library folders that the user has permission to view 3366 */ 3367 public static int filterCountByG_P_H_S(long groupId, long parentFolderId, 3368 boolean hidden, int status) { 3369 return getPersistence() 3370 .filterCountByG_P_H_S(groupId, parentFolderId, hidden, status); 3371 } 3372 3373 /** 3374 * Returns all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3375 * 3376 * @param groupId the group ID 3377 * @param mountPoint the mount point 3378 * @param parentFolderId the parent folder ID 3379 * @param hidden the hidden 3380 * @param status the status 3381 * @return the matching document library folders 3382 */ 3383 public static List<DLFolder> findByG_M_P_H_S(long groupId, 3384 boolean mountPoint, long parentFolderId, boolean hidden, int status) { 3385 return getPersistence() 3386 .findByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3387 hidden, status); 3388 } 3389 3390 /** 3391 * Returns a range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3392 * 3393 * <p> 3394 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3395 * </p> 3396 * 3397 * @param groupId the group ID 3398 * @param mountPoint the mount point 3399 * @param parentFolderId the parent folder ID 3400 * @param hidden the hidden 3401 * @param status the status 3402 * @param start the lower bound of the range of document library folders 3403 * @param end the upper bound of the range of document library folders (not inclusive) 3404 * @return the range of matching document library folders 3405 */ 3406 public static List<DLFolder> findByG_M_P_H_S(long groupId, 3407 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3408 int start, int end) { 3409 return getPersistence() 3410 .findByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3411 hidden, status, start, end); 3412 } 3413 3414 /** 3415 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3416 * 3417 * <p> 3418 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3419 * </p> 3420 * 3421 * @param groupId the group ID 3422 * @param mountPoint the mount point 3423 * @param parentFolderId the parent folder ID 3424 * @param hidden the hidden 3425 * @param status the status 3426 * @param start the lower bound of the range of document library folders 3427 * @param end the upper bound of the range of document library folders (not inclusive) 3428 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3429 * @return the ordered range of matching document library folders 3430 */ 3431 public static List<DLFolder> findByG_M_P_H_S(long groupId, 3432 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3433 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 3434 return getPersistence() 3435 .findByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3436 hidden, status, start, end, orderByComparator); 3437 } 3438 3439 /** 3440 * Returns an ordered range of all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3441 * 3442 * <p> 3443 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3444 * </p> 3445 * 3446 * @param groupId the group ID 3447 * @param mountPoint the mount point 3448 * @param parentFolderId the parent folder ID 3449 * @param hidden the hidden 3450 * @param status the status 3451 * @param start the lower bound of the range of document library folders 3452 * @param end the upper bound of the range of document library folders (not inclusive) 3453 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3454 * @param retrieveFromCache whether to retrieve from the finder cache 3455 * @return the ordered range of matching document library folders 3456 */ 3457 public static List<DLFolder> findByG_M_P_H_S(long groupId, 3458 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3459 int start, int end, OrderByComparator<DLFolder> orderByComparator, 3460 boolean retrieveFromCache) { 3461 return getPersistence() 3462 .findByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3463 hidden, status, start, end, orderByComparator, retrieveFromCache); 3464 } 3465 3466 /** 3467 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3468 * 3469 * @param groupId the group ID 3470 * @param mountPoint the mount point 3471 * @param parentFolderId the parent folder ID 3472 * @param hidden the hidden 3473 * @param status the status 3474 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3475 * @return the first matching document library folder 3476 * @throws NoSuchFolderException if a matching document library folder could not be found 3477 */ 3478 public static DLFolder findByG_M_P_H_S_First(long groupId, 3479 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3480 OrderByComparator<DLFolder> orderByComparator) 3481 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3482 return getPersistence() 3483 .findByG_M_P_H_S_First(groupId, mountPoint, parentFolderId, 3484 hidden, status, orderByComparator); 3485 } 3486 3487 /** 3488 * Returns the first document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3489 * 3490 * @param groupId the group ID 3491 * @param mountPoint the mount point 3492 * @param parentFolderId the parent folder ID 3493 * @param hidden the hidden 3494 * @param status the status 3495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3496 * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found 3497 */ 3498 public static DLFolder fetchByG_M_P_H_S_First(long groupId, 3499 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3500 OrderByComparator<DLFolder> orderByComparator) { 3501 return getPersistence() 3502 .fetchByG_M_P_H_S_First(groupId, mountPoint, parentFolderId, 3503 hidden, status, orderByComparator); 3504 } 3505 3506 /** 3507 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3508 * 3509 * @param groupId the group ID 3510 * @param mountPoint the mount point 3511 * @param parentFolderId the parent folder ID 3512 * @param hidden the hidden 3513 * @param status the status 3514 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3515 * @return the last matching document library folder 3516 * @throws NoSuchFolderException if a matching document library folder could not be found 3517 */ 3518 public static DLFolder findByG_M_P_H_S_Last(long groupId, 3519 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3520 OrderByComparator<DLFolder> orderByComparator) 3521 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3522 return getPersistence() 3523 .findByG_M_P_H_S_Last(groupId, mountPoint, parentFolderId, 3524 hidden, status, orderByComparator); 3525 } 3526 3527 /** 3528 * Returns the last document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3529 * 3530 * @param groupId the group ID 3531 * @param mountPoint the mount point 3532 * @param parentFolderId the parent folder ID 3533 * @param hidden the hidden 3534 * @param status the status 3535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3536 * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found 3537 */ 3538 public static DLFolder fetchByG_M_P_H_S_Last(long groupId, 3539 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3540 OrderByComparator<DLFolder> orderByComparator) { 3541 return getPersistence() 3542 .fetchByG_M_P_H_S_Last(groupId, mountPoint, parentFolderId, 3543 hidden, status, orderByComparator); 3544 } 3545 3546 /** 3547 * Returns the document library folders before and after the current document library folder in the ordered set where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3548 * 3549 * @param folderId the primary key of the current document library folder 3550 * @param groupId the group ID 3551 * @param mountPoint the mount point 3552 * @param parentFolderId the parent folder ID 3553 * @param hidden the hidden 3554 * @param status the status 3555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3556 * @return the previous, current, and next document library folder 3557 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3558 */ 3559 public static DLFolder[] findByG_M_P_H_S_PrevAndNext(long folderId, 3560 long groupId, boolean mountPoint, long parentFolderId, boolean hidden, 3561 int status, OrderByComparator<DLFolder> orderByComparator) 3562 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3563 return getPersistence() 3564 .findByG_M_P_H_S_PrevAndNext(folderId, groupId, mountPoint, 3565 parentFolderId, hidden, status, orderByComparator); 3566 } 3567 3568 /** 3569 * Returns all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3570 * 3571 * @param groupId the group ID 3572 * @param mountPoint the mount point 3573 * @param parentFolderId the parent folder ID 3574 * @param hidden the hidden 3575 * @param status the status 3576 * @return the matching document library folders that the user has permission to view 3577 */ 3578 public static List<DLFolder> filterFindByG_M_P_H_S(long groupId, 3579 boolean mountPoint, long parentFolderId, boolean hidden, int status) { 3580 return getPersistence() 3581 .filterFindByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3582 hidden, status); 3583 } 3584 3585 /** 3586 * Returns a range of all the document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3587 * 3588 * <p> 3589 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3590 * </p> 3591 * 3592 * @param groupId the group ID 3593 * @param mountPoint the mount point 3594 * @param parentFolderId the parent folder ID 3595 * @param hidden the hidden 3596 * @param status the status 3597 * @param start the lower bound of the range of document library folders 3598 * @param end the upper bound of the range of document library folders (not inclusive) 3599 * @return the range of matching document library folders that the user has permission to view 3600 */ 3601 public static List<DLFolder> filterFindByG_M_P_H_S(long groupId, 3602 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3603 int start, int end) { 3604 return getPersistence() 3605 .filterFindByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3606 hidden, status, start, end); 3607 } 3608 3609 /** 3610 * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3611 * 3612 * <p> 3613 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3614 * </p> 3615 * 3616 * @param groupId the group ID 3617 * @param mountPoint the mount point 3618 * @param parentFolderId the parent folder ID 3619 * @param hidden the hidden 3620 * @param status the status 3621 * @param start the lower bound of the range of document library folders 3622 * @param end the upper bound of the range of document library folders (not inclusive) 3623 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3624 * @return the ordered range of matching document library folders that the user has permission to view 3625 */ 3626 public static List<DLFolder> filterFindByG_M_P_H_S(long groupId, 3627 boolean mountPoint, long parentFolderId, boolean hidden, int status, 3628 int start, int end, OrderByComparator<DLFolder> orderByComparator) { 3629 return getPersistence() 3630 .filterFindByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3631 hidden, status, start, end, orderByComparator); 3632 } 3633 3634 /** 3635 * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3636 * 3637 * @param folderId the primary key of the current document library folder 3638 * @param groupId the group ID 3639 * @param mountPoint the mount point 3640 * @param parentFolderId the parent folder ID 3641 * @param hidden the hidden 3642 * @param status the status 3643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3644 * @return the previous, current, and next document library folder 3645 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3646 */ 3647 public static DLFolder[] filterFindByG_M_P_H_S_PrevAndNext(long folderId, 3648 long groupId, boolean mountPoint, long parentFolderId, boolean hidden, 3649 int status, OrderByComparator<DLFolder> orderByComparator) 3650 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3651 return getPersistence() 3652 .filterFindByG_M_P_H_S_PrevAndNext(folderId, groupId, 3653 mountPoint, parentFolderId, hidden, status, orderByComparator); 3654 } 3655 3656 /** 3657 * Removes all the document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ? from the database. 3658 * 3659 * @param groupId the group ID 3660 * @param mountPoint the mount point 3661 * @param parentFolderId the parent folder ID 3662 * @param hidden the hidden 3663 * @param status the status 3664 */ 3665 public static void removeByG_M_P_H_S(long groupId, boolean mountPoint, 3666 long parentFolderId, boolean hidden, int status) { 3667 getPersistence() 3668 .removeByG_M_P_H_S(groupId, mountPoint, parentFolderId, hidden, 3669 status); 3670 } 3671 3672 /** 3673 * Returns the number of document library folders where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3674 * 3675 * @param groupId the group ID 3676 * @param mountPoint the mount point 3677 * @param parentFolderId the parent folder ID 3678 * @param hidden the hidden 3679 * @param status the status 3680 * @return the number of matching document library folders 3681 */ 3682 public static int countByG_M_P_H_S(long groupId, boolean mountPoint, 3683 long parentFolderId, boolean hidden, int status) { 3684 return getPersistence() 3685 .countByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3686 hidden, status); 3687 } 3688 3689 /** 3690 * Returns the number of document library folders that the user has permission to view where groupId = ? and mountPoint = ? and parentFolderId = ? and hidden = ? and status = ?. 3691 * 3692 * @param groupId the group ID 3693 * @param mountPoint the mount point 3694 * @param parentFolderId the parent folder ID 3695 * @param hidden the hidden 3696 * @param status the status 3697 * @return the number of matching document library folders that the user has permission to view 3698 */ 3699 public static int filterCountByG_M_P_H_S(long groupId, boolean mountPoint, 3700 long parentFolderId, boolean hidden, int status) { 3701 return getPersistence() 3702 .filterCountByG_M_P_H_S(groupId, mountPoint, parentFolderId, 3703 hidden, status); 3704 } 3705 3706 /** 3707 * Caches the document library folder in the entity cache if it is enabled. 3708 * 3709 * @param dlFolder the document library folder 3710 */ 3711 public static void cacheResult(DLFolder dlFolder) { 3712 getPersistence().cacheResult(dlFolder); 3713 } 3714 3715 /** 3716 * Caches the document library folders in the entity cache if it is enabled. 3717 * 3718 * @param dlFolders the document library folders 3719 */ 3720 public static void cacheResult(List<DLFolder> dlFolders) { 3721 getPersistence().cacheResult(dlFolders); 3722 } 3723 3724 /** 3725 * Creates a new document library folder with the primary key. Does not add the document library folder to the database. 3726 * 3727 * @param folderId the primary key for the new document library folder 3728 * @return the new document library folder 3729 */ 3730 public static DLFolder create(long folderId) { 3731 return getPersistence().create(folderId); 3732 } 3733 3734 /** 3735 * Removes the document library folder with the primary key from the database. Also notifies the appropriate model listeners. 3736 * 3737 * @param folderId the primary key of the document library folder 3738 * @return the document library folder that was removed 3739 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3740 */ 3741 public static DLFolder remove(long folderId) 3742 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3743 return getPersistence().remove(folderId); 3744 } 3745 3746 public static DLFolder updateImpl(DLFolder dlFolder) { 3747 return getPersistence().updateImpl(dlFolder); 3748 } 3749 3750 /** 3751 * Returns the document library folder with the primary key or throws a {@link NoSuchFolderException} if it could not be found. 3752 * 3753 * @param folderId the primary key of the document library folder 3754 * @return the document library folder 3755 * @throws NoSuchFolderException if a document library folder with the primary key could not be found 3756 */ 3757 public static DLFolder findByPrimaryKey(long folderId) 3758 throws com.liferay.portlet.documentlibrary.exception.NoSuchFolderException { 3759 return getPersistence().findByPrimaryKey(folderId); 3760 } 3761 3762 /** 3763 * Returns the document library folder with the primary key or returns <code>null</code> if it could not be found. 3764 * 3765 * @param folderId the primary key of the document library folder 3766 * @return the document library folder, or <code>null</code> if a document library folder with the primary key could not be found 3767 */ 3768 public static DLFolder fetchByPrimaryKey(long folderId) { 3769 return getPersistence().fetchByPrimaryKey(folderId); 3770 } 3771 3772 public static java.util.Map<java.io.Serializable, DLFolder> fetchByPrimaryKeys( 3773 java.util.Set<java.io.Serializable> primaryKeys) { 3774 return getPersistence().fetchByPrimaryKeys(primaryKeys); 3775 } 3776 3777 /** 3778 * Returns all the document library folders. 3779 * 3780 * @return the document library folders 3781 */ 3782 public static List<DLFolder> findAll() { 3783 return getPersistence().findAll(); 3784 } 3785 3786 /** 3787 * Returns a range of all the document library folders. 3788 * 3789 * <p> 3790 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3791 * </p> 3792 * 3793 * @param start the lower bound of the range of document library folders 3794 * @param end the upper bound of the range of document library folders (not inclusive) 3795 * @return the range of document library folders 3796 */ 3797 public static List<DLFolder> findAll(int start, int end) { 3798 return getPersistence().findAll(start, end); 3799 } 3800 3801 /** 3802 * Returns an ordered range of all the document library folders. 3803 * 3804 * <p> 3805 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3806 * </p> 3807 * 3808 * @param start the lower bound of the range of document library folders 3809 * @param end the upper bound of the range of document library folders (not inclusive) 3810 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3811 * @return the ordered range of document library folders 3812 */ 3813 public static List<DLFolder> findAll(int start, int end, 3814 OrderByComparator<DLFolder> orderByComparator) { 3815 return getPersistence().findAll(start, end, orderByComparator); 3816 } 3817 3818 /** 3819 * Returns an ordered range of all the document library folders. 3820 * 3821 * <p> 3822 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3823 * </p> 3824 * 3825 * @param start the lower bound of the range of document library folders 3826 * @param end the upper bound of the range of document library folders (not inclusive) 3827 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3828 * @param retrieveFromCache whether to retrieve from the finder cache 3829 * @return the ordered range of document library folders 3830 */ 3831 public static List<DLFolder> findAll(int start, int end, 3832 OrderByComparator<DLFolder> orderByComparator, boolean retrieveFromCache) { 3833 return getPersistence() 3834 .findAll(start, end, orderByComparator, retrieveFromCache); 3835 } 3836 3837 /** 3838 * Removes all the document library folders from the database. 3839 */ 3840 public static void removeAll() { 3841 getPersistence().removeAll(); 3842 } 3843 3844 /** 3845 * Returns the number of document library folders. 3846 * 3847 * @return the number of document library folders 3848 */ 3849 public static int countAll() { 3850 return getPersistence().countAll(); 3851 } 3852 3853 /** 3854 * Returns the primaryKeys of document library file entry types associated with the document library folder. 3855 * 3856 * @param pk the primary key of the document library folder 3857 * @return long[] of the primaryKeys of document library file entry types associated with the document library folder 3858 */ 3859 public static long[] getDLFileEntryTypePrimaryKeys(long pk) { 3860 return getPersistence().getDLFileEntryTypePrimaryKeys(pk); 3861 } 3862 3863 /** 3864 * Returns all the document library file entry types associated with the document library folder. 3865 * 3866 * @param pk the primary key of the document library folder 3867 * @return the document library file entry types associated with the document library folder 3868 */ 3869 public static List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes( 3870 long pk) { 3871 return getPersistence().getDLFileEntryTypes(pk); 3872 } 3873 3874 /** 3875 * Returns a range of all the document library file entry types associated with the document library folder. 3876 * 3877 * <p> 3878 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3879 * </p> 3880 * 3881 * @param pk the primary key of the document library folder 3882 * @param start the lower bound of the range of document library folders 3883 * @param end the upper bound of the range of document library folders (not inclusive) 3884 * @return the range of document library file entry types associated with the document library folder 3885 */ 3886 public static List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes( 3887 long pk, int start, int end) { 3888 return getPersistence().getDLFileEntryTypes(pk, start, end); 3889 } 3890 3891 /** 3892 * Returns an ordered range of all the document library file entry types associated with the document library folder. 3893 * 3894 * <p> 3895 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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 DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3896 * </p> 3897 * 3898 * @param pk the primary key of the document library folder 3899 * @param start the lower bound of the range of document library folders 3900 * @param end the upper bound of the range of document library folders (not inclusive) 3901 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3902 * @return the ordered range of document library file entry types associated with the document library folder 3903 */ 3904 public static List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes( 3905 long pk, int start, int end, 3906 OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFileEntryType> orderByComparator) { 3907 return getPersistence() 3908 .getDLFileEntryTypes(pk, start, end, orderByComparator); 3909 } 3910 3911 /** 3912 * Returns the number of document library file entry types associated with the document library folder. 3913 * 3914 * @param pk the primary key of the document library folder 3915 * @return the number of document library file entry types associated with the document library folder 3916 */ 3917 public static int getDLFileEntryTypesSize(long pk) { 3918 return getPersistence().getDLFileEntryTypesSize(pk); 3919 } 3920 3921 /** 3922 * Returns <code>true</code> if the document library file entry type is associated with the document library folder. 3923 * 3924 * @param pk the primary key of the document library folder 3925 * @param dlFileEntryTypePK the primary key of the document library file entry type 3926 * @return <code>true</code> if the document library file entry type is associated with the document library folder; <code>false</code> otherwise 3927 */ 3928 public static boolean containsDLFileEntryType(long pk, 3929 long dlFileEntryTypePK) { 3930 return getPersistence().containsDLFileEntryType(pk, dlFileEntryTypePK); 3931 } 3932 3933 /** 3934 * Returns <code>true</code> if the document library folder has any document library file entry types associated with it. 3935 * 3936 * @param pk the primary key of the document library folder to check for associations with document library file entry types 3937 * @return <code>true</code> if the document library folder has any document library file entry types associated with it; <code>false</code> otherwise 3938 */ 3939 public static boolean containsDLFileEntryTypes(long pk) { 3940 return getPersistence().containsDLFileEntryTypes(pk); 3941 } 3942 3943 /** 3944 * Adds an association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3945 * 3946 * @param pk the primary key of the document library folder 3947 * @param dlFileEntryTypePK the primary key of the document library file entry type 3948 */ 3949 public static void addDLFileEntryType(long pk, long dlFileEntryTypePK) { 3950 getPersistence().addDLFileEntryType(pk, dlFileEntryTypePK); 3951 } 3952 3953 /** 3954 * Adds an association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3955 * 3956 * @param pk the primary key of the document library folder 3957 * @param dlFileEntryType the document library file entry type 3958 */ 3959 public static void addDLFileEntryType(long pk, 3960 com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType) { 3961 getPersistence().addDLFileEntryType(pk, dlFileEntryType); 3962 } 3963 3964 /** 3965 * Adds an association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3966 * 3967 * @param pk the primary key of the document library folder 3968 * @param dlFileEntryTypePKs the primary keys of the document library file entry types 3969 */ 3970 public static void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) { 3971 getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypePKs); 3972 } 3973 3974 /** 3975 * Adds an association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3976 * 3977 * @param pk the primary key of the document library folder 3978 * @param dlFileEntryTypes the document library file entry types 3979 */ 3980 public static void addDLFileEntryTypes(long pk, 3981 List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) { 3982 getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypes); 3983 } 3984 3985 /** 3986 * Clears all associations between the document library folder and its document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3987 * 3988 * @param pk the primary key of the document library folder to clear the associated document library file entry types from 3989 */ 3990 public static void clearDLFileEntryTypes(long pk) { 3991 getPersistence().clearDLFileEntryTypes(pk); 3992 } 3993 3994 /** 3995 * Removes the association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3996 * 3997 * @param pk the primary key of the document library folder 3998 * @param dlFileEntryTypePK the primary key of the document library file entry type 3999 */ 4000 public static void removeDLFileEntryType(long pk, long dlFileEntryTypePK) { 4001 getPersistence().removeDLFileEntryType(pk, dlFileEntryTypePK); 4002 } 4003 4004 /** 4005 * Removes the association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 4006 * 4007 * @param pk the primary key of the document library folder 4008 * @param dlFileEntryType the document library file entry type 4009 */ 4010 public static void removeDLFileEntryType(long pk, 4011 com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType) { 4012 getPersistence().removeDLFileEntryType(pk, dlFileEntryType); 4013 } 4014 4015 /** 4016 * Removes the association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 4017 * 4018 * @param pk the primary key of the document library folder 4019 * @param dlFileEntryTypePKs the primary keys of the document library file entry types 4020 */ 4021 public static void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) { 4022 getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypePKs); 4023 } 4024 4025 /** 4026 * Removes the association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 4027 * 4028 * @param pk the primary key of the document library folder 4029 * @param dlFileEntryTypes the document library file entry types 4030 */ 4031 public static void removeDLFileEntryTypes(long pk, 4032 List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) { 4033 getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypes); 4034 } 4035 4036 /** 4037 * Sets the document library file entry types associated with the document library folder, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 4038 * 4039 * @param pk the primary key of the document library folder 4040 * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the document library folder 4041 */ 4042 public static void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) { 4043 getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypePKs); 4044 } 4045 4046 /** 4047 * Sets the document library file entry types associated with the document library folder, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 4048 * 4049 * @param pk the primary key of the document library folder 4050 * @param dlFileEntryTypes the document library file entry types to be associated with the document library folder 4051 */ 4052 public static void setDLFileEntryTypes(long pk, 4053 List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) { 4054 getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypes); 4055 } 4056 4057 public static java.util.Set<java.lang.String> getBadColumnNames() { 4058 return getPersistence().getBadColumnNames(); 4059 } 4060 4061 public static DLFolderPersistence getPersistence() { 4062 if (_persistence == null) { 4063 _persistence = (DLFolderPersistence)PortalBeanLocatorUtil.locate(DLFolderPersistence.class.getName()); 4064 4065 ReferenceRegistry.registerReference(DLFolderUtil.class, 4066 "_persistence"); 4067 } 4068 4069 return _persistence; 4070 } 4071 4072 private static DLFolderPersistence _persistence; 4073 }