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.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.documentlibrary.model.DLFileEntry; 022 023 /** 024 * The persistence interface for the document library file entry service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryPersistenceImpl 032 * @see DLFileEntryUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface DLFileEntryPersistence extends BasePersistence<DLFileEntry> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link DLFileEntryUtil} to access the document library file entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the document library file entries where uuid = ?. 045 * 046 * @param uuid the uuid 047 * @return the matching document library file entries 048 */ 049 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid); 050 051 /** 052 * Returns a range of all the document library file entries where uuid = ?. 053 * 054 * <p> 055 * 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 DLFileEntryModelImpl}. 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. 056 * </p> 057 * 058 * @param uuid the uuid 059 * @param start the lower bound of the range of document library file entries 060 * @param end the upper bound of the range of document library file entries (not inclusive) 061 * @return the range of matching document library file entries 062 */ 063 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid, 064 int start, int end); 065 066 /** 067 * Returns an ordered range of all the document library file entries where uuid = ?. 068 * 069 * <p> 070 * 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 DLFileEntryModelImpl}. 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. 071 * </p> 072 * 073 * @param uuid the uuid 074 * @param start the lower bound of the range of document library file entries 075 * @param end the upper bound of the range of document library file entries (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching document library file entries 078 */ 079 public java.util.List<DLFileEntry> findByUuid(java.lang.String uuid, 080 int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 082 083 /** 084 * Returns the first document library file entry in the ordered set where uuid = ?. 085 * 086 * @param uuid the uuid 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching document library file entry 089 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 090 */ 091 public DLFileEntry findByUuid_First(java.lang.String uuid, 092 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 093 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 094 095 /** 096 * Returns the first document library file entry in the ordered set where uuid = ?. 097 * 098 * @param uuid the uuid 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 101 */ 102 public DLFileEntry fetchByUuid_First(java.lang.String uuid, 103 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 104 105 /** 106 * Returns the last document library file entry in the ordered set where uuid = ?. 107 * 108 * @param uuid the uuid 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching document library file entry 111 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 112 */ 113 public DLFileEntry findByUuid_Last(java.lang.String uuid, 114 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 115 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 116 117 /** 118 * Returns the last document library file entry in the ordered set where uuid = ?. 119 * 120 * @param uuid the uuid 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 123 */ 124 public DLFileEntry fetchByUuid_Last(java.lang.String uuid, 125 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 126 127 /** 128 * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = ?. 129 * 130 * @param fileEntryId the primary key of the current document library file entry 131 * @param uuid the uuid 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next document library file entry 134 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 135 */ 136 public DLFileEntry[] findByUuid_PrevAndNext(long fileEntryId, 137 java.lang.String uuid, 138 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 139 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 140 141 /** 142 * Removes all the document library file entries where uuid = ? from the database. 143 * 144 * @param uuid the uuid 145 */ 146 public void removeByUuid(java.lang.String uuid); 147 148 /** 149 * Returns the number of document library file entries where uuid = ?. 150 * 151 * @param uuid the uuid 152 * @return the number of matching document library file entries 153 */ 154 public int countByUuid(java.lang.String uuid); 155 156 /** 157 * Returns the document library file entry where uuid = ? and groupId = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 158 * 159 * @param uuid the uuid 160 * @param groupId the group ID 161 * @return the matching document library file entry 162 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 163 */ 164 public DLFileEntry findByUUID_G(java.lang.String uuid, long groupId) 165 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 166 167 /** 168 * Returns the document library file entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 169 * 170 * @param uuid the uuid 171 * @param groupId the group ID 172 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 173 */ 174 public DLFileEntry fetchByUUID_G(java.lang.String uuid, long groupId); 175 176 /** 177 * Returns the document library file entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 178 * 179 * @param uuid the uuid 180 * @param groupId the group ID 181 * @param retrieveFromCache whether to use the finder cache 182 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 183 */ 184 public DLFileEntry fetchByUUID_G(java.lang.String uuid, long groupId, 185 boolean retrieveFromCache); 186 187 /** 188 * Removes the document library file entry where uuid = ? and groupId = ? from the database. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the document library file entry that was removed 193 */ 194 public DLFileEntry removeByUUID_G(java.lang.String uuid, long groupId) 195 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 196 197 /** 198 * Returns the number of document library file entries where uuid = ? and groupId = ?. 199 * 200 * @param uuid the uuid 201 * @param groupId the group ID 202 * @return the number of matching document library file entries 203 */ 204 public int countByUUID_G(java.lang.String uuid, long groupId); 205 206 /** 207 * Returns all the document library file entries where uuid = ? and companyId = ?. 208 * 209 * @param uuid the uuid 210 * @param companyId the company ID 211 * @return the matching document library file entries 212 */ 213 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 214 long companyId); 215 216 /** 217 * Returns a range of all the document library file entries where uuid = ? and companyId = ?. 218 * 219 * <p> 220 * 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 DLFileEntryModelImpl}. 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. 221 * </p> 222 * 223 * @param uuid the uuid 224 * @param companyId the company ID 225 * @param start the lower bound of the range of document library file entries 226 * @param end the upper bound of the range of document library file entries (not inclusive) 227 * @return the range of matching document library file entries 228 */ 229 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 230 long companyId, int start, int end); 231 232 /** 233 * Returns an ordered range of all the document library file entries where uuid = ? and companyId = ?. 234 * 235 * <p> 236 * 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 DLFileEntryModelImpl}. 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. 237 * </p> 238 * 239 * @param uuid the uuid 240 * @param companyId the company ID 241 * @param start the lower bound of the range of document library file entries 242 * @param end the upper bound of the range of document library file entries (not inclusive) 243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 244 * @return the ordered range of matching document library file entries 245 */ 246 public java.util.List<DLFileEntry> findByUuid_C(java.lang.String uuid, 247 long companyId, int start, int end, 248 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 249 250 /** 251 * Returns the first document library file entry in the ordered set where uuid = ? and companyId = ?. 252 * 253 * @param uuid the uuid 254 * @param companyId the company ID 255 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 256 * @return the first matching document library file entry 257 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 258 */ 259 public DLFileEntry findByUuid_C_First(java.lang.String uuid, 260 long companyId, 261 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 262 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 263 264 /** 265 * Returns the first document library file entry in the ordered set where uuid = ? and companyId = ?. 266 * 267 * @param uuid the uuid 268 * @param companyId the company ID 269 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 270 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 271 */ 272 public DLFileEntry fetchByUuid_C_First(java.lang.String uuid, 273 long companyId, 274 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 275 276 /** 277 * Returns the last document library file entry in the ordered set where uuid = ? and companyId = ?. 278 * 279 * @param uuid the uuid 280 * @param companyId the company ID 281 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 282 * @return the last matching document library file entry 283 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 284 */ 285 public DLFileEntry findByUuid_C_Last(java.lang.String uuid, long companyId, 286 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 287 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 288 289 /** 290 * Returns the last document library file entry in the ordered set where uuid = ? and companyId = ?. 291 * 292 * @param uuid the uuid 293 * @param companyId the company ID 294 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 295 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 296 */ 297 public DLFileEntry fetchByUuid_C_Last(java.lang.String uuid, 298 long companyId, 299 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 300 301 /** 302 * Returns the document library file entries before and after the current document library file entry in the ordered set where uuid = ? and companyId = ?. 303 * 304 * @param fileEntryId the primary key of the current document library file entry 305 * @param uuid the uuid 306 * @param companyId the company ID 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 308 * @return the previous, current, and next document library file entry 309 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 310 */ 311 public DLFileEntry[] findByUuid_C_PrevAndNext(long fileEntryId, 312 java.lang.String uuid, long companyId, 313 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 314 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 315 316 /** 317 * Removes all the document library file entries where uuid = ? and companyId = ? from the database. 318 * 319 * @param uuid the uuid 320 * @param companyId the company ID 321 */ 322 public void removeByUuid_C(java.lang.String uuid, long companyId); 323 324 /** 325 * Returns the number of document library file entries where uuid = ? and companyId = ?. 326 * 327 * @param uuid the uuid 328 * @param companyId the company ID 329 * @return the number of matching document library file entries 330 */ 331 public int countByUuid_C(java.lang.String uuid, long companyId); 332 333 /** 334 * Returns all the document library file entries where groupId = ?. 335 * 336 * @param groupId the group ID 337 * @return the matching document library file entries 338 */ 339 public java.util.List<DLFileEntry> findByGroupId(long groupId); 340 341 /** 342 * Returns a range of all the document library file entries where groupId = ?. 343 * 344 * <p> 345 * 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 DLFileEntryModelImpl}. 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. 346 * </p> 347 * 348 * @param groupId the group ID 349 * @param start the lower bound of the range of document library file entries 350 * @param end the upper bound of the range of document library file entries (not inclusive) 351 * @return the range of matching document library file entries 352 */ 353 public java.util.List<DLFileEntry> findByGroupId(long groupId, int start, 354 int end); 355 356 /** 357 * Returns an ordered range of all the document library file entries where groupId = ?. 358 * 359 * <p> 360 * 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 DLFileEntryModelImpl}. 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. 361 * </p> 362 * 363 * @param groupId the group ID 364 * @param start the lower bound of the range of document library file entries 365 * @param end the upper bound of the range of document library file entries (not inclusive) 366 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 367 * @return the ordered range of matching document library file entries 368 */ 369 public java.util.List<DLFileEntry> findByGroupId(long groupId, int start, 370 int end, 371 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 372 373 /** 374 * Returns the first document library file entry in the ordered set where groupId = ?. 375 * 376 * @param groupId the group ID 377 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 378 * @return the first matching document library file entry 379 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 380 */ 381 public DLFileEntry findByGroupId_First(long groupId, 382 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 383 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 384 385 /** 386 * Returns the first document library file entry in the ordered set where groupId = ?. 387 * 388 * @param groupId the group ID 389 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 390 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 391 */ 392 public DLFileEntry fetchByGroupId_First(long groupId, 393 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 394 395 /** 396 * Returns the last document library file entry in the ordered set where groupId = ?. 397 * 398 * @param groupId the group ID 399 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 400 * @return the last matching document library file entry 401 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 402 */ 403 public DLFileEntry findByGroupId_Last(long groupId, 404 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 405 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 406 407 /** 408 * Returns the last document library file entry in the ordered set where groupId = ?. 409 * 410 * @param groupId the group ID 411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 412 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 413 */ 414 public DLFileEntry fetchByGroupId_Last(long groupId, 415 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 416 417 /** 418 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ?. 419 * 420 * @param fileEntryId the primary key of the current document library file entry 421 * @param groupId the group ID 422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 423 * @return the previous, current, and next document library file entry 424 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 425 */ 426 public DLFileEntry[] findByGroupId_PrevAndNext(long fileEntryId, 427 long groupId, 428 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 429 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 430 431 /** 432 * Returns all the document library file entries that the user has permission to view where groupId = ?. 433 * 434 * @param groupId the group ID 435 * @return the matching document library file entries that the user has permission to view 436 */ 437 public java.util.List<DLFileEntry> filterFindByGroupId(long groupId); 438 439 /** 440 * Returns a range of all the document library file entries that the user has permission to view where groupId = ?. 441 * 442 * <p> 443 * 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 DLFileEntryModelImpl}. 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. 444 * </p> 445 * 446 * @param groupId the group ID 447 * @param start the lower bound of the range of document library file entries 448 * @param end the upper bound of the range of document library file entries (not inclusive) 449 * @return the range of matching document library file entries that the user has permission to view 450 */ 451 public java.util.List<DLFileEntry> filterFindByGroupId(long groupId, 452 int start, int end); 453 454 /** 455 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ?. 456 * 457 * <p> 458 * 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 DLFileEntryModelImpl}. 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. 459 * </p> 460 * 461 * @param groupId the group ID 462 * @param start the lower bound of the range of document library file entries 463 * @param end the upper bound of the range of document library file entries (not inclusive) 464 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 465 * @return the ordered range of matching document library file entries that the user has permission to view 466 */ 467 public java.util.List<DLFileEntry> filterFindByGroupId(long groupId, 468 int start, int end, 469 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 470 471 /** 472 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ?. 473 * 474 * @param fileEntryId the primary key of the current document library file entry 475 * @param groupId the group ID 476 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 477 * @return the previous, current, and next document library file entry 478 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 479 */ 480 public DLFileEntry[] filterFindByGroupId_PrevAndNext(long fileEntryId, 481 long groupId, 482 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 483 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 484 485 /** 486 * Removes all the document library file entries where groupId = ? from the database. 487 * 488 * @param groupId the group ID 489 */ 490 public void removeByGroupId(long groupId); 491 492 /** 493 * Returns the number of document library file entries where groupId = ?. 494 * 495 * @param groupId the group ID 496 * @return the number of matching document library file entries 497 */ 498 public int countByGroupId(long groupId); 499 500 /** 501 * Returns the number of document library file entries that the user has permission to view where groupId = ?. 502 * 503 * @param groupId the group ID 504 * @return the number of matching document library file entries that the user has permission to view 505 */ 506 public int filterCountByGroupId(long groupId); 507 508 /** 509 * Returns all the document library file entries where companyId = ?. 510 * 511 * @param companyId the company ID 512 * @return the matching document library file entries 513 */ 514 public java.util.List<DLFileEntry> findByCompanyId(long companyId); 515 516 /** 517 * Returns a range of all the document library file entries where companyId = ?. 518 * 519 * <p> 520 * 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 DLFileEntryModelImpl}. 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. 521 * </p> 522 * 523 * @param companyId the company ID 524 * @param start the lower bound of the range of document library file entries 525 * @param end the upper bound of the range of document library file entries (not inclusive) 526 * @return the range of matching document library file entries 527 */ 528 public java.util.List<DLFileEntry> findByCompanyId(long companyId, 529 int start, int end); 530 531 /** 532 * Returns an ordered range of all the document library file entries where companyId = ?. 533 * 534 * <p> 535 * 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 DLFileEntryModelImpl}. 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. 536 * </p> 537 * 538 * @param companyId the company ID 539 * @param start the lower bound of the range of document library file entries 540 * @param end the upper bound of the range of document library file entries (not inclusive) 541 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 542 * @return the ordered range of matching document library file entries 543 */ 544 public java.util.List<DLFileEntry> findByCompanyId(long companyId, 545 int start, int end, 546 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 547 548 /** 549 * Returns the first document library file entry in the ordered set where companyId = ?. 550 * 551 * @param companyId the company ID 552 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 553 * @return the first matching document library file entry 554 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 555 */ 556 public DLFileEntry findByCompanyId_First(long companyId, 557 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 558 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 559 560 /** 561 * Returns the first document library file entry in the ordered set where companyId = ?. 562 * 563 * @param companyId the company ID 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 566 */ 567 public DLFileEntry fetchByCompanyId_First(long companyId, 568 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 569 570 /** 571 * Returns the last document library file entry in the ordered set where companyId = ?. 572 * 573 * @param companyId the company ID 574 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 575 * @return the last matching document library file entry 576 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 577 */ 578 public DLFileEntry findByCompanyId_Last(long companyId, 579 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 580 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 581 582 /** 583 * Returns the last document library file entry in the ordered set where companyId = ?. 584 * 585 * @param companyId the company ID 586 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 587 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 588 */ 589 public DLFileEntry fetchByCompanyId_Last(long companyId, 590 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 591 592 /** 593 * Returns the document library file entries before and after the current document library file entry in the ordered set where companyId = ?. 594 * 595 * @param fileEntryId the primary key of the current document library file entry 596 * @param companyId the company ID 597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 598 * @return the previous, current, and next document library file entry 599 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 600 */ 601 public DLFileEntry[] findByCompanyId_PrevAndNext(long fileEntryId, 602 long companyId, 603 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 604 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 605 606 /** 607 * Removes all the document library file entries where companyId = ? from the database. 608 * 609 * @param companyId the company ID 610 */ 611 public void removeByCompanyId(long companyId); 612 613 /** 614 * Returns the number of document library file entries where companyId = ?. 615 * 616 * @param companyId the company ID 617 * @return the number of matching document library file entries 618 */ 619 public int countByCompanyId(long companyId); 620 621 /** 622 * Returns all the document library file entries where repositoryId = ?. 623 * 624 * @param repositoryId the repository ID 625 * @return the matching document library file entries 626 */ 627 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId); 628 629 /** 630 * Returns a range of all the document library file entries where repositoryId = ?. 631 * 632 * <p> 633 * 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 DLFileEntryModelImpl}. 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. 634 * </p> 635 * 636 * @param repositoryId the repository ID 637 * @param start the lower bound of the range of document library file entries 638 * @param end the upper bound of the range of document library file entries (not inclusive) 639 * @return the range of matching document library file entries 640 */ 641 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId, 642 int start, int end); 643 644 /** 645 * Returns an ordered range of all the document library file entries where repositoryId = ?. 646 * 647 * <p> 648 * 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 DLFileEntryModelImpl}. 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. 649 * </p> 650 * 651 * @param repositoryId the repository ID 652 * @param start the lower bound of the range of document library file entries 653 * @param end the upper bound of the range of document library file entries (not inclusive) 654 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 655 * @return the ordered range of matching document library file entries 656 */ 657 public java.util.List<DLFileEntry> findByRepositoryId(long repositoryId, 658 int start, int end, 659 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 660 661 /** 662 * Returns the first document library file entry in the ordered set where repositoryId = ?. 663 * 664 * @param repositoryId the repository ID 665 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 666 * @return the first matching document library file entry 667 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 668 */ 669 public DLFileEntry findByRepositoryId_First(long repositoryId, 670 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 671 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 672 673 /** 674 * Returns the first document library file entry in the ordered set where repositoryId = ?. 675 * 676 * @param repositoryId the repository ID 677 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 678 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 679 */ 680 public DLFileEntry fetchByRepositoryId_First(long repositoryId, 681 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 682 683 /** 684 * Returns the last document library file entry in the ordered set where repositoryId = ?. 685 * 686 * @param repositoryId the repository ID 687 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 688 * @return the last matching document library file entry 689 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 690 */ 691 public DLFileEntry findByRepositoryId_Last(long repositoryId, 692 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 693 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 694 695 /** 696 * Returns the last document library file entry in the ordered set where repositoryId = ?. 697 * 698 * @param repositoryId the repository ID 699 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 700 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 701 */ 702 public DLFileEntry fetchByRepositoryId_Last(long repositoryId, 703 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 704 705 /** 706 * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = ?. 707 * 708 * @param fileEntryId the primary key of the current document library file entry 709 * @param repositoryId the repository ID 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the previous, current, and next document library file entry 712 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 713 */ 714 public DLFileEntry[] findByRepositoryId_PrevAndNext(long fileEntryId, 715 long repositoryId, 716 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 717 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 718 719 /** 720 * Removes all the document library file entries where repositoryId = ? from the database. 721 * 722 * @param repositoryId the repository ID 723 */ 724 public void removeByRepositoryId(long repositoryId); 725 726 /** 727 * Returns the number of document library file entries where repositoryId = ?. 728 * 729 * @param repositoryId the repository ID 730 * @return the number of matching document library file entries 731 */ 732 public int countByRepositoryId(long repositoryId); 733 734 /** 735 * Returns all the document library file entries where mimeType = ?. 736 * 737 * @param mimeType the mime type 738 * @return the matching document library file entries 739 */ 740 public java.util.List<DLFileEntry> findByMimeType(java.lang.String mimeType); 741 742 /** 743 * Returns a range of all the document library file entries where mimeType = ?. 744 * 745 * <p> 746 * 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 DLFileEntryModelImpl}. 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. 747 * </p> 748 * 749 * @param mimeType the mime type 750 * @param start the lower bound of the range of document library file entries 751 * @param end the upper bound of the range of document library file entries (not inclusive) 752 * @return the range of matching document library file entries 753 */ 754 public java.util.List<DLFileEntry> findByMimeType( 755 java.lang.String mimeType, int start, int end); 756 757 /** 758 * Returns an ordered range of all the document library file entries where mimeType = ?. 759 * 760 * <p> 761 * 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 DLFileEntryModelImpl}. 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. 762 * </p> 763 * 764 * @param mimeType the mime type 765 * @param start the lower bound of the range of document library file entries 766 * @param end the upper bound of the range of document library file entries (not inclusive) 767 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 768 * @return the ordered range of matching document library file entries 769 */ 770 public java.util.List<DLFileEntry> findByMimeType( 771 java.lang.String mimeType, int start, int end, 772 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 773 774 /** 775 * Returns the first document library file entry in the ordered set where mimeType = ?. 776 * 777 * @param mimeType the mime type 778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 779 * @return the first matching document library file entry 780 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 781 */ 782 public DLFileEntry findByMimeType_First(java.lang.String mimeType, 783 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 784 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 785 786 /** 787 * Returns the first document library file entry in the ordered set where mimeType = ?. 788 * 789 * @param mimeType the mime type 790 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 791 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 792 */ 793 public DLFileEntry fetchByMimeType_First(java.lang.String mimeType, 794 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 795 796 /** 797 * Returns the last document library file entry in the ordered set where mimeType = ?. 798 * 799 * @param mimeType the mime type 800 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 801 * @return the last matching document library file entry 802 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 803 */ 804 public DLFileEntry findByMimeType_Last(java.lang.String mimeType, 805 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 806 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 807 808 /** 809 * Returns the last document library file entry in the ordered set where mimeType = ?. 810 * 811 * @param mimeType the mime type 812 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 813 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 814 */ 815 public DLFileEntry fetchByMimeType_Last(java.lang.String mimeType, 816 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 817 818 /** 819 * Returns the document library file entries before and after the current document library file entry in the ordered set where mimeType = ?. 820 * 821 * @param fileEntryId the primary key of the current document library file entry 822 * @param mimeType the mime type 823 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 824 * @return the previous, current, and next document library file entry 825 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 826 */ 827 public DLFileEntry[] findByMimeType_PrevAndNext(long fileEntryId, 828 java.lang.String mimeType, 829 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 830 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 831 832 /** 833 * Removes all the document library file entries where mimeType = ? from the database. 834 * 835 * @param mimeType the mime type 836 */ 837 public void removeByMimeType(java.lang.String mimeType); 838 839 /** 840 * Returns the number of document library file entries where mimeType = ?. 841 * 842 * @param mimeType the mime type 843 * @return the number of matching document library file entries 844 */ 845 public int countByMimeType(java.lang.String mimeType); 846 847 /** 848 * Returns all the document library file entries where fileEntryTypeId = ?. 849 * 850 * @param fileEntryTypeId the file entry type ID 851 * @return the matching document library file entries 852 */ 853 public java.util.List<DLFileEntry> findByFileEntryTypeId( 854 long fileEntryTypeId); 855 856 /** 857 * Returns a range of all the document library file entries where fileEntryTypeId = ?. 858 * 859 * <p> 860 * 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 DLFileEntryModelImpl}. 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. 861 * </p> 862 * 863 * @param fileEntryTypeId the file entry type ID 864 * @param start the lower bound of the range of document library file entries 865 * @param end the upper bound of the range of document library file entries (not inclusive) 866 * @return the range of matching document library file entries 867 */ 868 public java.util.List<DLFileEntry> findByFileEntryTypeId( 869 long fileEntryTypeId, int start, int end); 870 871 /** 872 * Returns an ordered range of all the document library file entries where fileEntryTypeId = ?. 873 * 874 * <p> 875 * 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 DLFileEntryModelImpl}. 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. 876 * </p> 877 * 878 * @param fileEntryTypeId the file entry type ID 879 * @param start the lower bound of the range of document library file entries 880 * @param end the upper bound of the range of document library file entries (not inclusive) 881 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 882 * @return the ordered range of matching document library file entries 883 */ 884 public java.util.List<DLFileEntry> findByFileEntryTypeId( 885 long fileEntryTypeId, int start, int end, 886 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 887 888 /** 889 * Returns the first document library file entry in the ordered set where fileEntryTypeId = ?. 890 * 891 * @param fileEntryTypeId the file entry type ID 892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 893 * @return the first matching document library file entry 894 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 895 */ 896 public DLFileEntry findByFileEntryTypeId_First(long fileEntryTypeId, 897 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 898 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 899 900 /** 901 * Returns the first document library file entry in the ordered set where fileEntryTypeId = ?. 902 * 903 * @param fileEntryTypeId the file entry type ID 904 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 905 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 906 */ 907 public DLFileEntry fetchByFileEntryTypeId_First(long fileEntryTypeId, 908 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 909 910 /** 911 * Returns the last document library file entry in the ordered set where fileEntryTypeId = ?. 912 * 913 * @param fileEntryTypeId the file entry type ID 914 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 915 * @return the last matching document library file entry 916 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 917 */ 918 public DLFileEntry findByFileEntryTypeId_Last(long fileEntryTypeId, 919 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 920 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 921 922 /** 923 * Returns the last document library file entry in the ordered set where fileEntryTypeId = ?. 924 * 925 * @param fileEntryTypeId the file entry type ID 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 928 */ 929 public DLFileEntry fetchByFileEntryTypeId_Last(long fileEntryTypeId, 930 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 931 932 /** 933 * Returns the document library file entries before and after the current document library file entry in the ordered set where fileEntryTypeId = ?. 934 * 935 * @param fileEntryId the primary key of the current document library file entry 936 * @param fileEntryTypeId the file entry type ID 937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 938 * @return the previous, current, and next document library file entry 939 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 940 */ 941 public DLFileEntry[] findByFileEntryTypeId_PrevAndNext(long fileEntryId, 942 long fileEntryTypeId, 943 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 944 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 945 946 /** 947 * Removes all the document library file entries where fileEntryTypeId = ? from the database. 948 * 949 * @param fileEntryTypeId the file entry type ID 950 */ 951 public void removeByFileEntryTypeId(long fileEntryTypeId); 952 953 /** 954 * Returns the number of document library file entries where fileEntryTypeId = ?. 955 * 956 * @param fileEntryTypeId the file entry type ID 957 * @return the number of matching document library file entries 958 */ 959 public int countByFileEntryTypeId(long fileEntryTypeId); 960 961 /** 962 * Returns all the document library file entries where groupId = ? and userId = ?. 963 * 964 * @param groupId the group ID 965 * @param userId the user ID 966 * @return the matching document library file entries 967 */ 968 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId); 969 970 /** 971 * Returns a range of all the document library file entries where groupId = ? and userId = ?. 972 * 973 * <p> 974 * 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 DLFileEntryModelImpl}. 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. 975 * </p> 976 * 977 * @param groupId the group ID 978 * @param userId the user ID 979 * @param start the lower bound of the range of document library file entries 980 * @param end the upper bound of the range of document library file entries (not inclusive) 981 * @return the range of matching document library file entries 982 */ 983 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId, 984 int start, int end); 985 986 /** 987 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ?. 988 * 989 * <p> 990 * 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 DLFileEntryModelImpl}. 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. 991 * </p> 992 * 993 * @param groupId the group ID 994 * @param userId the user ID 995 * @param start the lower bound of the range of document library file entries 996 * @param end the upper bound of the range of document library file entries (not inclusive) 997 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 998 * @return the ordered range of matching document library file entries 999 */ 1000 public java.util.List<DLFileEntry> findByG_U(long groupId, long userId, 1001 int start, int end, 1002 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1003 1004 /** 1005 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ?. 1006 * 1007 * @param groupId the group ID 1008 * @param userId the user ID 1009 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1010 * @return the first matching document library file entry 1011 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1012 */ 1013 public DLFileEntry findByG_U_First(long groupId, long userId, 1014 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1015 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1016 1017 /** 1018 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ?. 1019 * 1020 * @param groupId the group ID 1021 * @param userId the user ID 1022 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1023 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1024 */ 1025 public DLFileEntry fetchByG_U_First(long groupId, long userId, 1026 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1027 1028 /** 1029 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ?. 1030 * 1031 * @param groupId the group ID 1032 * @param userId the user ID 1033 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1034 * @return the last matching document library file entry 1035 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1036 */ 1037 public DLFileEntry findByG_U_Last(long groupId, long userId, 1038 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1039 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1040 1041 /** 1042 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ?. 1043 * 1044 * @param groupId the group ID 1045 * @param userId the user ID 1046 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1047 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1048 */ 1049 public DLFileEntry fetchByG_U_Last(long groupId, long userId, 1050 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1051 1052 /** 1053 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and userId = ?. 1054 * 1055 * @param fileEntryId the primary key of the current document library file entry 1056 * @param groupId the group ID 1057 * @param userId the user ID 1058 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1059 * @return the previous, current, and next document library file entry 1060 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1061 */ 1062 public DLFileEntry[] findByG_U_PrevAndNext(long fileEntryId, long groupId, 1063 long userId, 1064 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1065 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1066 1067 /** 1068 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ?. 1069 * 1070 * @param groupId the group ID 1071 * @param userId the user ID 1072 * @return the matching document library file entries that the user has permission to view 1073 */ 1074 public java.util.List<DLFileEntry> filterFindByG_U(long groupId, long userId); 1075 1076 /** 1077 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ?. 1078 * 1079 * <p> 1080 * 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 DLFileEntryModelImpl}. 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. 1081 * </p> 1082 * 1083 * @param groupId the group ID 1084 * @param userId the user ID 1085 * @param start the lower bound of the range of document library file entries 1086 * @param end the upper bound of the range of document library file entries (not inclusive) 1087 * @return the range of matching document library file entries that the user has permission to view 1088 */ 1089 public java.util.List<DLFileEntry> filterFindByG_U(long groupId, 1090 long userId, int start, int end); 1091 1092 /** 1093 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and userId = ?. 1094 * 1095 * <p> 1096 * 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 DLFileEntryModelImpl}. 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. 1097 * </p> 1098 * 1099 * @param groupId the group ID 1100 * @param userId the user ID 1101 * @param start the lower bound of the range of document library file entries 1102 * @param end the upper bound of the range of document library file entries (not inclusive) 1103 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1104 * @return the ordered range of matching document library file entries that the user has permission to view 1105 */ 1106 public java.util.List<DLFileEntry> filterFindByG_U(long groupId, 1107 long userId, int start, int end, 1108 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1109 1110 /** 1111 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and userId = ?. 1112 * 1113 * @param fileEntryId the primary key of the current document library file entry 1114 * @param groupId the group ID 1115 * @param userId the user ID 1116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1117 * @return the previous, current, and next document library file entry 1118 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1119 */ 1120 public DLFileEntry[] filterFindByG_U_PrevAndNext(long fileEntryId, 1121 long groupId, long userId, 1122 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1123 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1124 1125 /** 1126 * Removes all the document library file entries where groupId = ? and userId = ? from the database. 1127 * 1128 * @param groupId the group ID 1129 * @param userId the user ID 1130 */ 1131 public void removeByG_U(long groupId, long userId); 1132 1133 /** 1134 * Returns the number of document library file entries where groupId = ? and userId = ?. 1135 * 1136 * @param groupId the group ID 1137 * @param userId the user ID 1138 * @return the number of matching document library file entries 1139 */ 1140 public int countByG_U(long groupId, long userId); 1141 1142 /** 1143 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ?. 1144 * 1145 * @param groupId the group ID 1146 * @param userId the user ID 1147 * @return the number of matching document library file entries that the user has permission to view 1148 */ 1149 public int filterCountByG_U(long groupId, long userId); 1150 1151 /** 1152 * Returns all the document library file entries where groupId = ? and folderId = ?. 1153 * 1154 * @param groupId the group ID 1155 * @param folderId the folder ID 1156 * @return the matching document library file entries 1157 */ 1158 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId); 1159 1160 /** 1161 * Returns a range of all the document library file entries where groupId = ? and folderId = ?. 1162 * 1163 * <p> 1164 * 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 DLFileEntryModelImpl}. 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. 1165 * </p> 1166 * 1167 * @param groupId the group ID 1168 * @param folderId the folder ID 1169 * @param start the lower bound of the range of document library file entries 1170 * @param end the upper bound of the range of document library file entries (not inclusive) 1171 * @return the range of matching document library file entries 1172 */ 1173 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId, 1174 int start, int end); 1175 1176 /** 1177 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ?. 1178 * 1179 * <p> 1180 * 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 DLFileEntryModelImpl}. 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. 1181 * </p> 1182 * 1183 * @param groupId the group ID 1184 * @param folderId the folder ID 1185 * @param start the lower bound of the range of document library file entries 1186 * @param end the upper bound of the range of document library file entries (not inclusive) 1187 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1188 * @return the ordered range of matching document library file entries 1189 */ 1190 public java.util.List<DLFileEntry> findByG_F(long groupId, long folderId, 1191 int start, int end, 1192 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1193 1194 /** 1195 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ?. 1196 * 1197 * @param groupId the group ID 1198 * @param folderId the folder ID 1199 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1200 * @return the first matching document library file entry 1201 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1202 */ 1203 public DLFileEntry findByG_F_First(long groupId, long folderId, 1204 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1205 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1206 1207 /** 1208 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ?. 1209 * 1210 * @param groupId the group ID 1211 * @param folderId the folder ID 1212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1213 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1214 */ 1215 public DLFileEntry fetchByG_F_First(long groupId, long folderId, 1216 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1217 1218 /** 1219 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ?. 1220 * 1221 * @param groupId the group ID 1222 * @param folderId the folder ID 1223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1224 * @return the last matching document library file entry 1225 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1226 */ 1227 public DLFileEntry findByG_F_Last(long groupId, long folderId, 1228 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1229 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1230 1231 /** 1232 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ?. 1233 * 1234 * @param groupId the group ID 1235 * @param folderId the folder ID 1236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1237 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1238 */ 1239 public DLFileEntry fetchByG_F_Last(long groupId, long folderId, 1240 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1241 1242 /** 1243 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and folderId = ?. 1244 * 1245 * @param fileEntryId the primary key of the current document library file entry 1246 * @param groupId the group ID 1247 * @param folderId the folder ID 1248 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1249 * @return the previous, current, and next document library file entry 1250 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1251 */ 1252 public DLFileEntry[] findByG_F_PrevAndNext(long fileEntryId, long groupId, 1253 long folderId, 1254 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1255 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1256 1257 /** 1258 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1259 * 1260 * @param groupId the group ID 1261 * @param folderId the folder ID 1262 * @return the matching document library file entries that the user has permission to view 1263 */ 1264 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1265 long folderId); 1266 1267 /** 1268 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1269 * 1270 * <p> 1271 * 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 DLFileEntryModelImpl}. 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. 1272 * </p> 1273 * 1274 * @param groupId the group ID 1275 * @param folderId the folder ID 1276 * @param start the lower bound of the range of document library file entries 1277 * @param end the upper bound of the range of document library file entries (not inclusive) 1278 * @return the range of matching document library file entries that the user has permission to view 1279 */ 1280 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1281 long folderId, int start, int end); 1282 1283 /** 1284 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and folderId = ?. 1285 * 1286 * <p> 1287 * 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 DLFileEntryModelImpl}. 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. 1288 * </p> 1289 * 1290 * @param groupId the group ID 1291 * @param folderId the folder ID 1292 * @param start the lower bound of the range of document library file entries 1293 * @param end the upper bound of the range of document library file entries (not inclusive) 1294 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1295 * @return the ordered range of matching document library file entries that the user has permission to view 1296 */ 1297 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1298 long folderId, int start, int end, 1299 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1300 1301 /** 1302 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1303 * 1304 * @param fileEntryId the primary key of the current document library file entry 1305 * @param groupId the group ID 1306 * @param folderId the folder ID 1307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1308 * @return the previous, current, and next document library file entry 1309 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1310 */ 1311 public DLFileEntry[] filterFindByG_F_PrevAndNext(long fileEntryId, 1312 long groupId, long folderId, 1313 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1314 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1315 1316 /** 1317 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1318 * 1319 * @param groupId the group ID 1320 * @param folderIds the folder IDs 1321 * @return the matching document library file entries that the user has permission to view 1322 */ 1323 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1324 long[] folderIds); 1325 1326 /** 1327 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1328 * 1329 * <p> 1330 * 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 DLFileEntryModelImpl}. 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. 1331 * </p> 1332 * 1333 * @param groupId the group ID 1334 * @param folderIds the folder IDs 1335 * @param start the lower bound of the range of document library file entries 1336 * @param end the upper bound of the range of document library file entries (not inclusive) 1337 * @return the range of matching document library file entries that the user has permission to view 1338 */ 1339 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1340 long[] folderIds, int start, int end); 1341 1342 /** 1343 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1344 * 1345 * <p> 1346 * 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 DLFileEntryModelImpl}. 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. 1347 * </p> 1348 * 1349 * @param groupId the group ID 1350 * @param folderIds the folder IDs 1351 * @param start the lower bound of the range of document library file entries 1352 * @param end the upper bound of the range of document library file entries (not inclusive) 1353 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1354 * @return the ordered range of matching document library file entries that the user has permission to view 1355 */ 1356 public java.util.List<DLFileEntry> filterFindByG_F(long groupId, 1357 long[] folderIds, int start, int end, 1358 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1359 1360 /** 1361 * Returns all the document library file entries where groupId = ? and folderId = any ?. 1362 * 1363 * <p> 1364 * 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 DLFileEntryModelImpl}. 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. 1365 * </p> 1366 * 1367 * @param groupId the group ID 1368 * @param folderIds the folder IDs 1369 * @return the matching document library file entries 1370 */ 1371 public java.util.List<DLFileEntry> findByG_F(long groupId, long[] folderIds); 1372 1373 /** 1374 * Returns a range of all the document library file entries where groupId = ? and folderId = any ?. 1375 * 1376 * <p> 1377 * 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 DLFileEntryModelImpl}. 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. 1378 * </p> 1379 * 1380 * @param groupId the group ID 1381 * @param folderIds the folder IDs 1382 * @param start the lower bound of the range of document library file entries 1383 * @param end the upper bound of the range of document library file entries (not inclusive) 1384 * @return the range of matching document library file entries 1385 */ 1386 public java.util.List<DLFileEntry> findByG_F(long groupId, 1387 long[] folderIds, int start, int end); 1388 1389 /** 1390 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = any ?. 1391 * 1392 * <p> 1393 * 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 DLFileEntryModelImpl}. 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. 1394 * </p> 1395 * 1396 * @param groupId the group ID 1397 * @param folderIds the folder IDs 1398 * @param start the lower bound of the range of document library file entries 1399 * @param end the upper bound of the range of document library file entries (not inclusive) 1400 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1401 * @return the ordered range of matching document library file entries 1402 */ 1403 public java.util.List<DLFileEntry> findByG_F(long groupId, 1404 long[] folderIds, int start, int end, 1405 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1406 1407 /** 1408 * Removes all the document library file entries where groupId = ? and folderId = ? from the database. 1409 * 1410 * @param groupId the group ID 1411 * @param folderId the folder ID 1412 */ 1413 public void removeByG_F(long groupId, long folderId); 1414 1415 /** 1416 * Returns the number of document library file entries where groupId = ? and folderId = ?. 1417 * 1418 * @param groupId the group ID 1419 * @param folderId the folder ID 1420 * @return the number of matching document library file entries 1421 */ 1422 public int countByG_F(long groupId, long folderId); 1423 1424 /** 1425 * Returns the number of document library file entries where groupId = ? and folderId = any ?. 1426 * 1427 * @param groupId the group ID 1428 * @param folderIds the folder IDs 1429 * @return the number of matching document library file entries 1430 */ 1431 public int countByG_F(long groupId, long[] folderIds); 1432 1433 /** 1434 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = ?. 1435 * 1436 * @param groupId the group ID 1437 * @param folderId the folder ID 1438 * @return the number of matching document library file entries that the user has permission to view 1439 */ 1440 public int filterCountByG_F(long groupId, long folderId); 1441 1442 /** 1443 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = any ?. 1444 * 1445 * @param groupId the group ID 1446 * @param folderIds the folder IDs 1447 * @return the number of matching document library file entries that the user has permission to view 1448 */ 1449 public int filterCountByG_F(long groupId, long[] folderIds); 1450 1451 /** 1452 * Returns all the document library file entries where repositoryId = ? and folderId = ?. 1453 * 1454 * @param repositoryId the repository ID 1455 * @param folderId the folder ID 1456 * @return the matching document library file entries 1457 */ 1458 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1459 long folderId); 1460 1461 /** 1462 * Returns a range of all the document library file entries where repositoryId = ? and folderId = ?. 1463 * 1464 * <p> 1465 * 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 DLFileEntryModelImpl}. 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. 1466 * </p> 1467 * 1468 * @param repositoryId the repository ID 1469 * @param folderId the folder ID 1470 * @param start the lower bound of the range of document library file entries 1471 * @param end the upper bound of the range of document library file entries (not inclusive) 1472 * @return the range of matching document library file entries 1473 */ 1474 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1475 long folderId, int start, int end); 1476 1477 /** 1478 * Returns an ordered range of all the document library file entries where repositoryId = ? and folderId = ?. 1479 * 1480 * <p> 1481 * 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 DLFileEntryModelImpl}. 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. 1482 * </p> 1483 * 1484 * @param repositoryId the repository ID 1485 * @param folderId the folder ID 1486 * @param start the lower bound of the range of document library file entries 1487 * @param end the upper bound of the range of document library file entries (not inclusive) 1488 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1489 * @return the ordered range of matching document library file entries 1490 */ 1491 public java.util.List<DLFileEntry> findByR_F(long repositoryId, 1492 long folderId, int start, int end, 1493 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1494 1495 /** 1496 * Returns the first document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1497 * 1498 * @param repositoryId the repository ID 1499 * @param folderId the folder ID 1500 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1501 * @return the first matching document library file entry 1502 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1503 */ 1504 public DLFileEntry findByR_F_First(long repositoryId, long folderId, 1505 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1506 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1507 1508 /** 1509 * Returns the first document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1510 * 1511 * @param repositoryId the repository ID 1512 * @param folderId the folder ID 1513 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1514 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1515 */ 1516 public DLFileEntry fetchByR_F_First(long repositoryId, long folderId, 1517 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1518 1519 /** 1520 * Returns the last document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1521 * 1522 * @param repositoryId the repository ID 1523 * @param folderId the folder ID 1524 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1525 * @return the last matching document library file entry 1526 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1527 */ 1528 public DLFileEntry findByR_F_Last(long repositoryId, long folderId, 1529 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1530 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1531 1532 /** 1533 * Returns the last document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1534 * 1535 * @param repositoryId the repository ID 1536 * @param folderId the folder ID 1537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1538 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1539 */ 1540 public DLFileEntry fetchByR_F_Last(long repositoryId, long folderId, 1541 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1542 1543 /** 1544 * Returns the document library file entries before and after the current document library file entry in the ordered set where repositoryId = ? and folderId = ?. 1545 * 1546 * @param fileEntryId the primary key of the current document library file entry 1547 * @param repositoryId the repository ID 1548 * @param folderId the folder ID 1549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1550 * @return the previous, current, and next document library file entry 1551 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1552 */ 1553 public DLFileEntry[] findByR_F_PrevAndNext(long fileEntryId, 1554 long repositoryId, long folderId, 1555 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1556 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1557 1558 /** 1559 * Removes all the document library file entries where repositoryId = ? and folderId = ? from the database. 1560 * 1561 * @param repositoryId the repository ID 1562 * @param folderId the folder ID 1563 */ 1564 public void removeByR_F(long repositoryId, long folderId); 1565 1566 /** 1567 * Returns the number of document library file entries where repositoryId = ? and folderId = ?. 1568 * 1569 * @param repositoryId the repository ID 1570 * @param folderId the folder ID 1571 * @return the number of matching document library file entries 1572 */ 1573 public int countByR_F(long repositoryId, long folderId); 1574 1575 /** 1576 * Returns all the document library file entries where folderId = ? and name = ?. 1577 * 1578 * @param folderId the folder ID 1579 * @param name the name 1580 * @return the matching document library file entries 1581 */ 1582 public java.util.List<DLFileEntry> findByF_N(long folderId, 1583 java.lang.String name); 1584 1585 /** 1586 * Returns a range of all the document library file entries where folderId = ? and name = ?. 1587 * 1588 * <p> 1589 * 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 DLFileEntryModelImpl}. 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. 1590 * </p> 1591 * 1592 * @param folderId the folder ID 1593 * @param name the name 1594 * @param start the lower bound of the range of document library file entries 1595 * @param end the upper bound of the range of document library file entries (not inclusive) 1596 * @return the range of matching document library file entries 1597 */ 1598 public java.util.List<DLFileEntry> findByF_N(long folderId, 1599 java.lang.String name, int start, int end); 1600 1601 /** 1602 * Returns an ordered range of all the document library file entries where folderId = ? and name = ?. 1603 * 1604 * <p> 1605 * 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 DLFileEntryModelImpl}. 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. 1606 * </p> 1607 * 1608 * @param folderId the folder ID 1609 * @param name the name 1610 * @param start the lower bound of the range of document library file entries 1611 * @param end the upper bound of the range of document library file entries (not inclusive) 1612 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1613 * @return the ordered range of matching document library file entries 1614 */ 1615 public java.util.List<DLFileEntry> findByF_N(long folderId, 1616 java.lang.String name, int start, int end, 1617 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1618 1619 /** 1620 * Returns the first document library file entry in the ordered set where folderId = ? and name = ?. 1621 * 1622 * @param folderId the folder ID 1623 * @param name the name 1624 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1625 * @return the first matching document library file entry 1626 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1627 */ 1628 public DLFileEntry findByF_N_First(long folderId, java.lang.String name, 1629 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1630 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1631 1632 /** 1633 * Returns the first document library file entry in the ordered set where folderId = ? and name = ?. 1634 * 1635 * @param folderId the folder ID 1636 * @param name the name 1637 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1638 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1639 */ 1640 public DLFileEntry fetchByF_N_First(long folderId, java.lang.String name, 1641 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1642 1643 /** 1644 * Returns the last document library file entry in the ordered set where folderId = ? and name = ?. 1645 * 1646 * @param folderId the folder ID 1647 * @param name the name 1648 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1649 * @return the last matching document library file entry 1650 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1651 */ 1652 public DLFileEntry findByF_N_Last(long folderId, java.lang.String name, 1653 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1654 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1655 1656 /** 1657 * Returns the last document library file entry in the ordered set where folderId = ? and name = ?. 1658 * 1659 * @param folderId the folder ID 1660 * @param name the name 1661 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1662 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1663 */ 1664 public DLFileEntry fetchByF_N_Last(long folderId, java.lang.String name, 1665 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1666 1667 /** 1668 * Returns the document library file entries before and after the current document library file entry in the ordered set where folderId = ? and name = ?. 1669 * 1670 * @param fileEntryId the primary key of the current document library file entry 1671 * @param folderId the folder ID 1672 * @param name the name 1673 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1674 * @return the previous, current, and next document library file entry 1675 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1676 */ 1677 public DLFileEntry[] findByF_N_PrevAndNext(long fileEntryId, long folderId, 1678 java.lang.String name, 1679 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1680 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1681 1682 /** 1683 * Removes all the document library file entries where folderId = ? and name = ? from the database. 1684 * 1685 * @param folderId the folder ID 1686 * @param name the name 1687 */ 1688 public void removeByF_N(long folderId, java.lang.String name); 1689 1690 /** 1691 * Returns the number of document library file entries where folderId = ? and name = ?. 1692 * 1693 * @param folderId the folder ID 1694 * @param name the name 1695 * @return the number of matching document library file entries 1696 */ 1697 public int countByF_N(long folderId, java.lang.String name); 1698 1699 /** 1700 * Returns all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1701 * 1702 * @param groupId the group ID 1703 * @param userId the user ID 1704 * @param folderId the folder ID 1705 * @return the matching document library file entries 1706 */ 1707 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1708 long folderId); 1709 1710 /** 1711 * Returns a range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1712 * 1713 * <p> 1714 * 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 DLFileEntryModelImpl}. 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. 1715 * </p> 1716 * 1717 * @param groupId the group ID 1718 * @param userId the user ID 1719 * @param folderId the folder ID 1720 * @param start the lower bound of the range of document library file entries 1721 * @param end the upper bound of the range of document library file entries (not inclusive) 1722 * @return the range of matching document library file entries 1723 */ 1724 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1725 long folderId, int start, int end); 1726 1727 /** 1728 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = ?. 1729 * 1730 * <p> 1731 * 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 DLFileEntryModelImpl}. 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. 1732 * </p> 1733 * 1734 * @param groupId the group ID 1735 * @param userId the user ID 1736 * @param folderId the folder ID 1737 * @param start the lower bound of the range of document library file entries 1738 * @param end the upper bound of the range of document library file entries (not inclusive) 1739 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1740 * @return the ordered range of matching document library file entries 1741 */ 1742 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1743 long folderId, int start, int end, 1744 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1745 1746 /** 1747 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 1748 * 1749 * @param groupId the group ID 1750 * @param userId the user ID 1751 * @param folderId the folder ID 1752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1753 * @return the first matching document library file entry 1754 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1755 */ 1756 public DLFileEntry findByG_U_F_First(long groupId, long userId, 1757 long folderId, 1758 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1759 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1760 1761 /** 1762 * Returns the first document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 1763 * 1764 * @param groupId the group ID 1765 * @param userId the user ID 1766 * @param folderId the folder ID 1767 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1768 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1769 */ 1770 public DLFileEntry fetchByG_U_F_First(long groupId, long userId, 1771 long folderId, 1772 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1773 1774 /** 1775 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 1776 * 1777 * @param groupId the group ID 1778 * @param userId the user ID 1779 * @param folderId the folder ID 1780 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1781 * @return the last matching document library file entry 1782 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 1783 */ 1784 public DLFileEntry findByG_U_F_Last(long groupId, long userId, 1785 long folderId, 1786 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1787 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1788 1789 /** 1790 * Returns the last document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 1791 * 1792 * @param groupId the group ID 1793 * @param userId the user ID 1794 * @param folderId the folder ID 1795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1796 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 1797 */ 1798 public DLFileEntry fetchByG_U_F_Last(long groupId, long userId, 1799 long folderId, 1800 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1801 1802 /** 1803 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and userId = ? and folderId = ?. 1804 * 1805 * @param fileEntryId the primary key of the current document library file entry 1806 * @param groupId the group ID 1807 * @param userId the user ID 1808 * @param folderId the folder ID 1809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1810 * @return the previous, current, and next document library file entry 1811 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1812 */ 1813 public DLFileEntry[] findByG_U_F_PrevAndNext(long fileEntryId, 1814 long groupId, long userId, long folderId, 1815 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1816 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1817 1818 /** 1819 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 1820 * 1821 * @param groupId the group ID 1822 * @param userId the user ID 1823 * @param folderId the folder ID 1824 * @return the matching document library file entries that the user has permission to view 1825 */ 1826 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 1827 long userId, long folderId); 1828 1829 /** 1830 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 1831 * 1832 * <p> 1833 * 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 DLFileEntryModelImpl}. 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. 1834 * </p> 1835 * 1836 * @param groupId the group ID 1837 * @param userId the user ID 1838 * @param folderId the folder ID 1839 * @param start the lower bound of the range of document library file entries 1840 * @param end the upper bound of the range of document library file entries (not inclusive) 1841 * @return the range of matching document library file entries that the user has permission to view 1842 */ 1843 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 1844 long userId, long folderId, int start, int end); 1845 1846 /** 1847 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ?. 1848 * 1849 * <p> 1850 * 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 DLFileEntryModelImpl}. 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. 1851 * </p> 1852 * 1853 * @param groupId the group ID 1854 * @param userId the user ID 1855 * @param folderId the folder ID 1856 * @param start the lower bound of the range of document library file entries 1857 * @param end the upper bound of the range of document library file entries (not inclusive) 1858 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1859 * @return the ordered range of matching document library file entries that the user has permission to view 1860 */ 1861 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 1862 long userId, long folderId, int start, int end, 1863 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1864 1865 /** 1866 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 1867 * 1868 * @param fileEntryId the primary key of the current document library file entry 1869 * @param groupId the group ID 1870 * @param userId the user ID 1871 * @param folderId the folder ID 1872 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1873 * @return the previous, current, and next document library file entry 1874 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 1875 */ 1876 public DLFileEntry[] filterFindByG_U_F_PrevAndNext(long fileEntryId, 1877 long groupId, long userId, long folderId, 1878 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 1879 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 1880 1881 /** 1882 * Returns all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 1883 * 1884 * @param groupId the group ID 1885 * @param userId the user ID 1886 * @param folderIds the folder IDs 1887 * @return the matching document library file entries that the user has permission to view 1888 */ 1889 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 1890 long userId, long[] folderIds); 1891 1892 /** 1893 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 1894 * 1895 * <p> 1896 * 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 DLFileEntryModelImpl}. 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. 1897 * </p> 1898 * 1899 * @param groupId the group ID 1900 * @param userId the user ID 1901 * @param folderIds the folder IDs 1902 * @param start the lower bound of the range of document library file entries 1903 * @param end the upper bound of the range of document library file entries (not inclusive) 1904 * @return the range of matching document library file entries that the user has permission to view 1905 */ 1906 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 1907 long userId, long[] folderIds, int start, int end); 1908 1909 /** 1910 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 1911 * 1912 * <p> 1913 * 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 DLFileEntryModelImpl}. 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. 1914 * </p> 1915 * 1916 * @param groupId the group ID 1917 * @param userId the user ID 1918 * @param folderIds the folder IDs 1919 * @param start the lower bound of the range of document library file entries 1920 * @param end the upper bound of the range of document library file entries (not inclusive) 1921 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1922 * @return the ordered range of matching document library file entries that the user has permission to view 1923 */ 1924 public java.util.List<DLFileEntry> filterFindByG_U_F(long groupId, 1925 long userId, long[] folderIds, int start, int end, 1926 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1927 1928 /** 1929 * Returns all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 1930 * 1931 * <p> 1932 * 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 DLFileEntryModelImpl}. 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. 1933 * </p> 1934 * 1935 * @param groupId the group ID 1936 * @param userId the user ID 1937 * @param folderIds the folder IDs 1938 * @return the matching document library file entries 1939 */ 1940 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1941 long[] folderIds); 1942 1943 /** 1944 * Returns a range of all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 1945 * 1946 * <p> 1947 * 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 DLFileEntryModelImpl}. 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. 1948 * </p> 1949 * 1950 * @param groupId the group ID 1951 * @param userId the user ID 1952 * @param folderIds the folder IDs 1953 * @param start the lower bound of the range of document library file entries 1954 * @param end the upper bound of the range of document library file entries (not inclusive) 1955 * @return the range of matching document library file entries 1956 */ 1957 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1958 long[] folderIds, int start, int end); 1959 1960 /** 1961 * Returns an ordered range of all the document library file entries where groupId = ? and userId = ? and folderId = any ?. 1962 * 1963 * <p> 1964 * 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 DLFileEntryModelImpl}. 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. 1965 * </p> 1966 * 1967 * @param groupId the group ID 1968 * @param userId the user ID 1969 * @param folderIds the folder IDs 1970 * @param start the lower bound of the range of document library file entries 1971 * @param end the upper bound of the range of document library file entries (not inclusive) 1972 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1973 * @return the ordered range of matching document library file entries 1974 */ 1975 public java.util.List<DLFileEntry> findByG_U_F(long groupId, long userId, 1976 long[] folderIds, int start, int end, 1977 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 1978 1979 /** 1980 * Removes all the document library file entries where groupId = ? and userId = ? and folderId = ? from the database. 1981 * 1982 * @param groupId the group ID 1983 * @param userId the user ID 1984 * @param folderId the folder ID 1985 */ 1986 public void removeByG_U_F(long groupId, long userId, long folderId); 1987 1988 /** 1989 * Returns the number of document library file entries where groupId = ? and userId = ? and folderId = ?. 1990 * 1991 * @param groupId the group ID 1992 * @param userId the user ID 1993 * @param folderId the folder ID 1994 * @return the number of matching document library file entries 1995 */ 1996 public int countByG_U_F(long groupId, long userId, long folderId); 1997 1998 /** 1999 * Returns the number of document library file entries where groupId = ? and userId = ? and folderId = any ?. 2000 * 2001 * @param groupId the group ID 2002 * @param userId the user ID 2003 * @param folderIds the folder IDs 2004 * @return the number of matching document library file entries 2005 */ 2006 public int countByG_U_F(long groupId, long userId, long[] folderIds); 2007 2008 /** 2009 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = ?. 2010 * 2011 * @param groupId the group ID 2012 * @param userId the user ID 2013 * @param folderId the folder ID 2014 * @return the number of matching document library file entries that the user has permission to view 2015 */ 2016 public int filterCountByG_U_F(long groupId, long userId, long folderId); 2017 2018 /** 2019 * Returns the number of document library file entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ?. 2020 * 2021 * @param groupId the group ID 2022 * @param userId the user ID 2023 * @param folderIds the folder IDs 2024 * @return the number of matching document library file entries that the user has permission to view 2025 */ 2026 public int filterCountByG_U_F(long groupId, long userId, long[] folderIds); 2027 2028 /** 2029 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2030 * 2031 * @param groupId the group ID 2032 * @param folderId the folder ID 2033 * @param name the name 2034 * @return the matching document library file entry 2035 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2036 */ 2037 public DLFileEntry findByG_F_N(long groupId, long folderId, 2038 java.lang.String name) 2039 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2040 2041 /** 2042 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2043 * 2044 * @param groupId the group ID 2045 * @param folderId the folder ID 2046 * @param name the name 2047 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2048 */ 2049 public DLFileEntry fetchByG_F_N(long groupId, long folderId, 2050 java.lang.String name); 2051 2052 /** 2053 * Returns the document library file entry where groupId = ? and folderId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2054 * 2055 * @param groupId the group ID 2056 * @param folderId the folder ID 2057 * @param name the name 2058 * @param retrieveFromCache whether to use the finder cache 2059 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2060 */ 2061 public DLFileEntry fetchByG_F_N(long groupId, long folderId, 2062 java.lang.String name, boolean retrieveFromCache); 2063 2064 /** 2065 * Removes the document library file entry where groupId = ? and folderId = ? and name = ? from the database. 2066 * 2067 * @param groupId the group ID 2068 * @param folderId the folder ID 2069 * @param name the name 2070 * @return the document library file entry that was removed 2071 */ 2072 public DLFileEntry removeByG_F_N(long groupId, long folderId, 2073 java.lang.String name) 2074 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2075 2076 /** 2077 * Returns the number of document library file entries where groupId = ? and folderId = ? and name = ?. 2078 * 2079 * @param groupId the group ID 2080 * @param folderId the folder ID 2081 * @param name the name 2082 * @return the number of matching document library file entries 2083 */ 2084 public int countByG_F_N(long groupId, long folderId, java.lang.String name); 2085 2086 /** 2087 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2088 * 2089 * @param groupId the group ID 2090 * @param folderId the folder ID 2091 * @param fileName the file name 2092 * @return the matching document library file entry 2093 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2094 */ 2095 public DLFileEntry findByG_F_FN(long groupId, long folderId, 2096 java.lang.String fileName) 2097 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2098 2099 /** 2100 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2101 * 2102 * @param groupId the group ID 2103 * @param folderId the folder ID 2104 * @param fileName the file name 2105 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2106 */ 2107 public DLFileEntry fetchByG_F_FN(long groupId, long folderId, 2108 java.lang.String fileName); 2109 2110 /** 2111 * Returns the document library file entry where groupId = ? and folderId = ? and fileName = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2112 * 2113 * @param groupId the group ID 2114 * @param folderId the folder ID 2115 * @param fileName the file name 2116 * @param retrieveFromCache whether to use the finder cache 2117 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2118 */ 2119 public DLFileEntry fetchByG_F_FN(long groupId, long folderId, 2120 java.lang.String fileName, boolean retrieveFromCache); 2121 2122 /** 2123 * Removes the document library file entry where groupId = ? and folderId = ? and fileName = ? from the database. 2124 * 2125 * @param groupId the group ID 2126 * @param folderId the folder ID 2127 * @param fileName the file name 2128 * @return the document library file entry that was removed 2129 */ 2130 public DLFileEntry removeByG_F_FN(long groupId, long folderId, 2131 java.lang.String fileName) 2132 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2133 2134 /** 2135 * Returns the number of document library file entries where groupId = ? and folderId = ? and fileName = ?. 2136 * 2137 * @param groupId the group ID 2138 * @param folderId the folder ID 2139 * @param fileName the file name 2140 * @return the number of matching document library file entries 2141 */ 2142 public int countByG_F_FN(long groupId, long folderId, 2143 java.lang.String fileName); 2144 2145 /** 2146 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or throws a {@link NoSuchFileEntryException} if it could not be found. 2147 * 2148 * @param groupId the group ID 2149 * @param folderId the folder ID 2150 * @param title the title 2151 * @return the matching document library file entry 2152 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2153 */ 2154 public DLFileEntry findByG_F_T(long groupId, long folderId, 2155 java.lang.String title) 2156 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2157 2158 /** 2159 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2160 * 2161 * @param groupId the group ID 2162 * @param folderId the folder ID 2163 * @param title the title 2164 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2165 */ 2166 public DLFileEntry fetchByG_F_T(long groupId, long folderId, 2167 java.lang.String title); 2168 2169 /** 2170 * Returns the document library file entry where groupId = ? and folderId = ? and title = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2171 * 2172 * @param groupId the group ID 2173 * @param folderId the folder ID 2174 * @param title the title 2175 * @param retrieveFromCache whether to use the finder cache 2176 * @return the matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2177 */ 2178 public DLFileEntry fetchByG_F_T(long groupId, long folderId, 2179 java.lang.String title, boolean retrieveFromCache); 2180 2181 /** 2182 * Removes the document library file entry where groupId = ? and folderId = ? and title = ? from the database. 2183 * 2184 * @param groupId the group ID 2185 * @param folderId the folder ID 2186 * @param title the title 2187 * @return the document library file entry that was removed 2188 */ 2189 public DLFileEntry removeByG_F_T(long groupId, long folderId, 2190 java.lang.String title) 2191 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2192 2193 /** 2194 * Returns the number of document library file entries where groupId = ? and folderId = ? and title = ?. 2195 * 2196 * @param groupId the group ID 2197 * @param folderId the folder ID 2198 * @param title the title 2199 * @return the number of matching document library file entries 2200 */ 2201 public int countByG_F_T(long groupId, long folderId, java.lang.String title); 2202 2203 /** 2204 * Returns all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2205 * 2206 * @param groupId the group ID 2207 * @param folderId the folder ID 2208 * @param fileEntryTypeId the file entry type ID 2209 * @return the matching document library file entries 2210 */ 2211 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2212 long fileEntryTypeId); 2213 2214 /** 2215 * Returns a range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2216 * 2217 * <p> 2218 * 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 DLFileEntryModelImpl}. 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. 2219 * </p> 2220 * 2221 * @param groupId the group ID 2222 * @param folderId the folder ID 2223 * @param fileEntryTypeId the file entry type ID 2224 * @param start the lower bound of the range of document library file entries 2225 * @param end the upper bound of the range of document library file entries (not inclusive) 2226 * @return the range of matching document library file entries 2227 */ 2228 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2229 long fileEntryTypeId, int start, int end); 2230 2231 /** 2232 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2233 * 2234 * <p> 2235 * 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 DLFileEntryModelImpl}. 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. 2236 * </p> 2237 * 2238 * @param groupId the group ID 2239 * @param folderId the folder ID 2240 * @param fileEntryTypeId the file entry type ID 2241 * @param start the lower bound of the range of document library file entries 2242 * @param end the upper bound of the range of document library file entries (not inclusive) 2243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2244 * @return the ordered range of matching document library file entries 2245 */ 2246 public java.util.List<DLFileEntry> findByG_F_F(long groupId, long folderId, 2247 long fileEntryTypeId, int start, int end, 2248 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2249 2250 /** 2251 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2252 * 2253 * @param groupId the group ID 2254 * @param folderId the folder ID 2255 * @param fileEntryTypeId the file entry type ID 2256 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2257 * @return the first matching document library file entry 2258 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2259 */ 2260 public DLFileEntry findByG_F_F_First(long groupId, long folderId, 2261 long fileEntryTypeId, 2262 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2263 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2264 2265 /** 2266 * Returns the first document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2267 * 2268 * @param groupId the group ID 2269 * @param folderId the folder ID 2270 * @param fileEntryTypeId the file entry type ID 2271 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2272 * @return the first matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2273 */ 2274 public DLFileEntry fetchByG_F_F_First(long groupId, long folderId, 2275 long fileEntryTypeId, 2276 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2277 2278 /** 2279 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2280 * 2281 * @param groupId the group ID 2282 * @param folderId the folder ID 2283 * @param fileEntryTypeId the file entry type ID 2284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2285 * @return the last matching document library file entry 2286 * @throws NoSuchFileEntryException if a matching document library file entry could not be found 2287 */ 2288 public DLFileEntry findByG_F_F_Last(long groupId, long folderId, 2289 long fileEntryTypeId, 2290 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2291 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2292 2293 /** 2294 * Returns the last document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2295 * 2296 * @param groupId the group ID 2297 * @param folderId the folder ID 2298 * @param fileEntryTypeId the file entry type ID 2299 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2300 * @return the last matching document library file entry, or <code>null</code> if a matching document library file entry could not be found 2301 */ 2302 public DLFileEntry fetchByG_F_F_Last(long groupId, long folderId, 2303 long fileEntryTypeId, 2304 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2305 2306 /** 2307 * Returns the document library file entries before and after the current document library file entry in the ordered set where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2308 * 2309 * @param fileEntryId the primary key of the current document library file entry 2310 * @param groupId the group ID 2311 * @param folderId the folder ID 2312 * @param fileEntryTypeId the file entry type ID 2313 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2314 * @return the previous, current, and next document library file entry 2315 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2316 */ 2317 public DLFileEntry[] findByG_F_F_PrevAndNext(long fileEntryId, 2318 long groupId, long folderId, long fileEntryTypeId, 2319 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2320 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2321 2322 /** 2323 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2324 * 2325 * @param groupId the group ID 2326 * @param folderId the folder ID 2327 * @param fileEntryTypeId the file entry type ID 2328 * @return the matching document library file entries that the user has permission to view 2329 */ 2330 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2331 long folderId, long fileEntryTypeId); 2332 2333 /** 2334 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2335 * 2336 * <p> 2337 * 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 DLFileEntryModelImpl}. 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. 2338 * </p> 2339 * 2340 * @param groupId the group ID 2341 * @param folderId the folder ID 2342 * @param fileEntryTypeId the file entry type ID 2343 * @param start the lower bound of the range of document library file entries 2344 * @param end the upper bound of the range of document library file entries (not inclusive) 2345 * @return the range of matching document library file entries that the user has permission to view 2346 */ 2347 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2348 long folderId, long fileEntryTypeId, int start, int end); 2349 2350 /** 2351 * Returns an ordered range of all the document library file entries that the user has permissions to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2352 * 2353 * <p> 2354 * 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 DLFileEntryModelImpl}. 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. 2355 * </p> 2356 * 2357 * @param groupId the group ID 2358 * @param folderId the folder ID 2359 * @param fileEntryTypeId the file entry type ID 2360 * @param start the lower bound of the range of document library file entries 2361 * @param end the upper bound of the range of document library file entries (not inclusive) 2362 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2363 * @return the ordered range of matching document library file entries that the user has permission to view 2364 */ 2365 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2366 long folderId, long fileEntryTypeId, int start, int end, 2367 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2368 2369 /** 2370 * Returns the document library file entries before and after the current document library file entry in the ordered set of document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2371 * 2372 * @param fileEntryId the primary key of the current document library file entry 2373 * @param groupId the group ID 2374 * @param folderId the folder ID 2375 * @param fileEntryTypeId the file entry type ID 2376 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2377 * @return the previous, current, and next document library file entry 2378 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2379 */ 2380 public DLFileEntry[] filterFindByG_F_F_PrevAndNext(long fileEntryId, 2381 long groupId, long folderId, long fileEntryTypeId, 2382 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator) 2383 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2384 2385 /** 2386 * Returns all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2387 * 2388 * @param groupId the group ID 2389 * @param folderIds the folder IDs 2390 * @param fileEntryTypeId the file entry type ID 2391 * @return the matching document library file entries that the user has permission to view 2392 */ 2393 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2394 long[] folderIds, long fileEntryTypeId); 2395 2396 /** 2397 * Returns a range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2398 * 2399 * <p> 2400 * 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 DLFileEntryModelImpl}. 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. 2401 * </p> 2402 * 2403 * @param groupId the group ID 2404 * @param folderIds the folder IDs 2405 * @param fileEntryTypeId the file entry type ID 2406 * @param start the lower bound of the range of document library file entries 2407 * @param end the upper bound of the range of document library file entries (not inclusive) 2408 * @return the range of matching document library file entries that the user has permission to view 2409 */ 2410 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2411 long[] folderIds, long fileEntryTypeId, int start, int end); 2412 2413 /** 2414 * Returns an ordered range of all the document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2415 * 2416 * <p> 2417 * 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 DLFileEntryModelImpl}. 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. 2418 * </p> 2419 * 2420 * @param groupId the group ID 2421 * @param folderIds the folder IDs 2422 * @param fileEntryTypeId the file entry type ID 2423 * @param start the lower bound of the range of document library file entries 2424 * @param end the upper bound of the range of document library file entries (not inclusive) 2425 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2426 * @return the ordered range of matching document library file entries that the user has permission to view 2427 */ 2428 public java.util.List<DLFileEntry> filterFindByG_F_F(long groupId, 2429 long[] folderIds, long fileEntryTypeId, int start, int end, 2430 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2431 2432 /** 2433 * Returns all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2434 * 2435 * <p> 2436 * 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 DLFileEntryModelImpl}. 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. 2437 * </p> 2438 * 2439 * @param groupId the group ID 2440 * @param folderIds the folder IDs 2441 * @param fileEntryTypeId the file entry type ID 2442 * @return the matching document library file entries 2443 */ 2444 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2445 long[] folderIds, long fileEntryTypeId); 2446 2447 /** 2448 * Returns a range of all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2449 * 2450 * <p> 2451 * 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 DLFileEntryModelImpl}. 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. 2452 * </p> 2453 * 2454 * @param groupId the group ID 2455 * @param folderIds the folder IDs 2456 * @param fileEntryTypeId the file entry type ID 2457 * @param start the lower bound of the range of document library file entries 2458 * @param end the upper bound of the range of document library file entries (not inclusive) 2459 * @return the range of matching document library file entries 2460 */ 2461 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2462 long[] folderIds, long fileEntryTypeId, int start, int end); 2463 2464 /** 2465 * Returns an ordered range of all the document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2466 * 2467 * <p> 2468 * 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 DLFileEntryModelImpl}. 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. 2469 * </p> 2470 * 2471 * @param groupId the group ID 2472 * @param folderIds the folder IDs 2473 * @param fileEntryTypeId the file entry type ID 2474 * @param start the lower bound of the range of document library file entries 2475 * @param end the upper bound of the range of document library file entries (not inclusive) 2476 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2477 * @return the ordered range of matching document library file entries 2478 */ 2479 public java.util.List<DLFileEntry> findByG_F_F(long groupId, 2480 long[] folderIds, long fileEntryTypeId, int start, int end, 2481 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2482 2483 /** 2484 * Removes all the document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ? from the database. 2485 * 2486 * @param groupId the group ID 2487 * @param folderId the folder ID 2488 * @param fileEntryTypeId the file entry type ID 2489 */ 2490 public void removeByG_F_F(long groupId, long folderId, long fileEntryTypeId); 2491 2492 /** 2493 * Returns the number of document library file entries where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2494 * 2495 * @param groupId the group ID 2496 * @param folderId the folder ID 2497 * @param fileEntryTypeId the file entry type ID 2498 * @return the number of matching document library file entries 2499 */ 2500 public int countByG_F_F(long groupId, long folderId, long fileEntryTypeId); 2501 2502 /** 2503 * Returns the number of document library file entries where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2504 * 2505 * @param groupId the group ID 2506 * @param folderIds the folder IDs 2507 * @param fileEntryTypeId the file entry type ID 2508 * @return the number of matching document library file entries 2509 */ 2510 public int countByG_F_F(long groupId, long[] folderIds, long fileEntryTypeId); 2511 2512 /** 2513 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = ? and fileEntryTypeId = ?. 2514 * 2515 * @param groupId the group ID 2516 * @param folderId the folder ID 2517 * @param fileEntryTypeId the file entry type ID 2518 * @return the number of matching document library file entries that the user has permission to view 2519 */ 2520 public int filterCountByG_F_F(long groupId, long folderId, 2521 long fileEntryTypeId); 2522 2523 /** 2524 * Returns the number of document library file entries that the user has permission to view where groupId = ? and folderId = any ? and fileEntryTypeId = ?. 2525 * 2526 * @param groupId the group ID 2527 * @param folderIds the folder IDs 2528 * @param fileEntryTypeId the file entry type ID 2529 * @return the number of matching document library file entries that the user has permission to view 2530 */ 2531 public int filterCountByG_F_F(long groupId, long[] folderIds, 2532 long fileEntryTypeId); 2533 2534 /** 2535 * Caches the document library file entry in the entity cache if it is enabled. 2536 * 2537 * @param dlFileEntry the document library file entry 2538 */ 2539 public void cacheResult(DLFileEntry dlFileEntry); 2540 2541 /** 2542 * Caches the document library file entries in the entity cache if it is enabled. 2543 * 2544 * @param dlFileEntries the document library file entries 2545 */ 2546 public void cacheResult(java.util.List<DLFileEntry> dlFileEntries); 2547 2548 /** 2549 * Creates a new document library file entry with the primary key. Does not add the document library file entry to the database. 2550 * 2551 * @param fileEntryId the primary key for the new document library file entry 2552 * @return the new document library file entry 2553 */ 2554 public DLFileEntry create(long fileEntryId); 2555 2556 /** 2557 * Removes the document library file entry with the primary key from the database. Also notifies the appropriate model listeners. 2558 * 2559 * @param fileEntryId the primary key of the document library file entry 2560 * @return the document library file entry that was removed 2561 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2562 */ 2563 public DLFileEntry remove(long fileEntryId) 2564 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2565 2566 public DLFileEntry updateImpl(DLFileEntry dlFileEntry); 2567 2568 /** 2569 * Returns the document library file entry with the primary key or throws a {@link NoSuchFileEntryException} if it could not be found. 2570 * 2571 * @param fileEntryId the primary key of the document library file entry 2572 * @return the document library file entry 2573 * @throws NoSuchFileEntryException if a document library file entry with the primary key could not be found 2574 */ 2575 public DLFileEntry findByPrimaryKey(long fileEntryId) 2576 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryException; 2577 2578 /** 2579 * Returns the document library file entry with the primary key or returns <code>null</code> if it could not be found. 2580 * 2581 * @param fileEntryId the primary key of the document library file entry 2582 * @return the document library file entry, or <code>null</code> if a document library file entry with the primary key could not be found 2583 */ 2584 public DLFileEntry fetchByPrimaryKey(long fileEntryId); 2585 2586 @Override 2587 public java.util.Map<java.io.Serializable, DLFileEntry> fetchByPrimaryKeys( 2588 java.util.Set<java.io.Serializable> primaryKeys); 2589 2590 /** 2591 * Returns all the document library file entries. 2592 * 2593 * @return the document library file entries 2594 */ 2595 public java.util.List<DLFileEntry> findAll(); 2596 2597 /** 2598 * Returns a range of all the document library file entries. 2599 * 2600 * <p> 2601 * 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 DLFileEntryModelImpl}. 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. 2602 * </p> 2603 * 2604 * @param start the lower bound of the range of document library file entries 2605 * @param end the upper bound of the range of document library file entries (not inclusive) 2606 * @return the range of document library file entries 2607 */ 2608 public java.util.List<DLFileEntry> findAll(int start, int end); 2609 2610 /** 2611 * Returns an ordered range of all the document library file entries. 2612 * 2613 * <p> 2614 * 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 DLFileEntryModelImpl}. 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. 2615 * </p> 2616 * 2617 * @param start the lower bound of the range of document library file entries 2618 * @param end the upper bound of the range of document library file entries (not inclusive) 2619 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2620 * @return the ordered range of document library file entries 2621 */ 2622 public java.util.List<DLFileEntry> findAll(int start, int end, 2623 com.liferay.portal.kernel.util.OrderByComparator<DLFileEntry> orderByComparator); 2624 2625 /** 2626 * Removes all the document library file entries from the database. 2627 */ 2628 public void removeAll(); 2629 2630 /** 2631 * Returns the number of document library file entries. 2632 * 2633 * @return the number of document library file entries 2634 */ 2635 public int countAll(); 2636 }