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