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