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; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.util.ReferenceRegistry; 021 022 /** 023 * Provides the remote service utility for DLApp. This utility wraps 024 * {@link com.liferay.portlet.documentlibrary.service.impl.DLAppServiceImpl} and is the 025 * primary access point for service operations in application layer code running 026 * on a remote server. Methods of this service are expected to have security 027 * checks based on the propagated JAAS credentials because this service can be 028 * accessed remotely. 029 * 030 * @author Brian Wing Shun Chan 031 * @see DLAppService 032 * @see com.liferay.portlet.documentlibrary.service.base.DLAppServiceBaseImpl 033 * @see com.liferay.portlet.documentlibrary.service.impl.DLAppServiceImpl 034 * @generated 035 */ 036 @ProviderType 037 public class DLAppServiceUtil { 038 /* 039 * NOTE FOR DEVELOPERS: 040 * 041 * Never modify this class directly. Add custom service methods to {@link com.liferay.portlet.documentlibrary.service.impl.DLAppServiceImpl} and rerun ServiceBuilder to regenerate this class. 042 */ 043 044 /** 045 * Adds a file entry and associated metadata. It is created based on a byte 046 * array. 047 * 048 * <p> 049 * This method takes two file names, the <code>sourceFileName</code> and the 050 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 051 * name of the actual file being uploaded. The <code>title</code> 052 * corresponds to a name the client wishes to assign this file after it has 053 * been uploaded to the portal. If it is <code>null</code>, the <code> 054 * sourceFileName</code> will be used. 055 * </p> 056 * 057 * @param repositoryId the primary key of the repository 058 * @param folderId the primary key of the file entry's parent folder 059 * @param sourceFileName the original file's name 060 * @param mimeType the file's MIME type 061 * @param title the name to be assigned to the file (optionally <code>null 062 </code>) 063 * @param description the file's description 064 * @param changeLog the file's version change log 065 * @param bytes the file's data (optionally <code>null</code>) 066 * @param serviceContext the service context to be applied. Can set the 067 asset category IDs, asset tag names, and expando bridge 068 attributes for the file entry. In a Liferay repository, it may 069 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 070 type </li> <li> fieldsMap - mapping for fields associated with a 071 custom file entry type </li> </ul> 072 * @return the file entry 073 * @throws PortalException if the parent folder could not be found or if the 074 file entry's information was invalid 075 */ 076 public static com.liferay.portal.kernel.repository.model.FileEntry addFileEntry( 077 long repositoryId, long folderId, java.lang.String sourceFileName, 078 java.lang.String mimeType, java.lang.String title, 079 java.lang.String description, java.lang.String changeLog, byte[] bytes, 080 com.liferay.portal.service.ServiceContext serviceContext) 081 throws com.liferay.portal.kernel.exception.PortalException { 082 return getService() 083 .addFileEntry(repositoryId, folderId, sourceFileName, 084 mimeType, title, description, changeLog, bytes, serviceContext); 085 } 086 087 /** 088 * Adds a file entry and associated metadata. It is created based on a 089 * {@link java.io.File} object. 090 * 091 * <p> 092 * This method takes two file names, the <code>sourceFileName</code> and the 093 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 094 * name of the actual file being uploaded. The <code>title</code> 095 * corresponds to a name the client wishes to assign this file after it has 096 * been uploaded to the portal. If it is <code>null</code>, the <code> 097 * sourceFileName</code> will be used. 098 * </p> 099 * 100 * @param repositoryId the primary key of the repository 101 * @param folderId the primary key of the file entry's parent folder 102 * @param sourceFileName the original file's name 103 * @param mimeType the file's MIME type 104 * @param title the name to be assigned to the file (optionally <code>null 105 </code>) 106 * @param description the file's description 107 * @param changeLog the file's version change log 108 * @param file the file's data (optionally <code>null</code>) 109 * @param serviceContext the service context to be applied. Can set the 110 asset category IDs, asset tag names, and expando bridge 111 attributes for the file entry. In a Liferay repository, it may 112 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 113 type </li> <li> fieldsMap - mapping for fields associated with a 114 custom file entry type </li> </ul> 115 * @return the file entry 116 * @throws PortalException if the parent folder could not be found or if the 117 file entry's information was invalid 118 */ 119 public static com.liferay.portal.kernel.repository.model.FileEntry addFileEntry( 120 long repositoryId, long folderId, java.lang.String sourceFileName, 121 java.lang.String mimeType, java.lang.String title, 122 java.lang.String description, java.lang.String changeLog, 123 java.io.File file, 124 com.liferay.portal.service.ServiceContext serviceContext) 125 throws com.liferay.portal.kernel.exception.PortalException { 126 return getService() 127 .addFileEntry(repositoryId, folderId, sourceFileName, 128 mimeType, title, description, changeLog, file, serviceContext); 129 } 130 131 /** 132 * Adds a file entry and associated metadata. It is created based on a 133 * {@link InputStream} object. 134 * 135 * <p> 136 * This method takes two file names, the <code>sourceFileName</code> and the 137 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 138 * name of the actual file being uploaded. The <code>title</code> 139 * corresponds to a name the client wishes to assign this file after it has 140 * been uploaded to the portal. If it is <code>null</code>, the <code> 141 * sourceFileName</code> will be used. 142 * </p> 143 * 144 * @param repositoryId the primary key of the repository 145 * @param folderId the primary key of the file entry's parent folder 146 * @param sourceFileName the original file's name 147 * @param mimeType the file's MIME type 148 * @param title the name to be assigned to the file (optionally <code>null 149 </code>) 150 * @param description the file's description 151 * @param changeLog the file's version change log 152 * @param is the file's data (optionally <code>null</code>) 153 * @param size the file's size (optionally <code>0</code>) 154 * @param serviceContext the service context to be applied. Can set the 155 asset category IDs, asset tag names, and expando bridge 156 attributes for the file entry. In a Liferay repository, it may 157 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 158 type </li> <li> fieldsMap - mapping for fields associated with a 159 custom file entry type </li> </ul> 160 * @return the file entry 161 * @throws PortalException if the parent folder could not be found or if the 162 file entry's information was invalid 163 */ 164 public static com.liferay.portal.kernel.repository.model.FileEntry addFileEntry( 165 long repositoryId, long folderId, java.lang.String sourceFileName, 166 java.lang.String mimeType, java.lang.String title, 167 java.lang.String description, java.lang.String changeLog, 168 java.io.InputStream is, long size, 169 com.liferay.portal.service.ServiceContext serviceContext) 170 throws com.liferay.portal.kernel.exception.PortalException { 171 return getService() 172 .addFileEntry(repositoryId, folderId, sourceFileName, 173 mimeType, title, description, changeLog, is, size, serviceContext); 174 } 175 176 /** 177 * Adds a file shortcut to the existing file entry. This method is only 178 * supported by the Liferay repository. 179 * 180 * @param repositoryId the primary key of the repository 181 * @param folderId the primary key of the file shortcut's parent folder 182 * @param toFileEntryId the primary key of the file shortcut's file entry 183 * @param serviceContext the service context to be applied. Can set the 184 asset category IDs, asset tag names, and expando bridge 185 attributes for the file entry. 186 * @return the file shortcut 187 * @throws PortalException if the parent folder or file entry could not be 188 found, or if the file shortcut's information was invalid 189 */ 190 public static com.liferay.portlet.documentlibrary.model.DLFileShortcut addFileShortcut( 191 long repositoryId, long folderId, long toFileEntryId, 192 com.liferay.portal.service.ServiceContext serviceContext) 193 throws com.liferay.portal.kernel.exception.PortalException { 194 return getService() 195 .addFileShortcut(repositoryId, folderId, toFileEntryId, 196 serviceContext); 197 } 198 199 /** 200 * Adds a folder. 201 * 202 * @param repositoryId the primary key of the repository 203 * @param parentFolderId the primary key of the folder's parent folder 204 * @param name the folder's name 205 * @param description the folder's description 206 * @param serviceContext the service context to be applied. In a Liferay 207 repository, it may include boolean mountPoint specifying whether 208 folder is a facade for mounting a third-party repository 209 * @return the folder 210 * @throws PortalException if the parent folder could not be found or if the 211 new folder's information was invalid 212 */ 213 public static com.liferay.portal.kernel.repository.model.Folder addFolder( 214 long repositoryId, long parentFolderId, java.lang.String name, 215 java.lang.String description, 216 com.liferay.portal.service.ServiceContext serviceContext) 217 throws com.liferay.portal.kernel.exception.PortalException { 218 return getService() 219 .addFolder(repositoryId, parentFolderId, name, description, 220 serviceContext); 221 } 222 223 /** 224 * Adds a temporary file entry. 225 * 226 * <p> 227 * This allows a client to upload a file into a temporary location and 228 * manipulate its metadata prior to making it available for public usage. 229 * This is different from checking in and checking out a file entry. 230 * </p> 231 * 232 * @param groupId the primary key of the group 233 * @param folderId the primary key of the folder where the file entry will 234 eventually reside 235 * @param folderName the temporary folder's name 236 * @param fileName the file's original name 237 * @param file the file's data (optionally <code>null</code>) 238 * @param mimeType the file's MIME type 239 * @return the temporary file entry 240 * @throws PortalException if the file name was invalid 241 * @see com.liferay.portal.kernel.util.TempFileEntryUtil 242 */ 243 public static com.liferay.portal.kernel.repository.model.FileEntry addTempFileEntry( 244 long groupId, long folderId, java.lang.String folderName, 245 java.lang.String fileName, java.io.File file, java.lang.String mimeType) 246 throws com.liferay.portal.kernel.exception.PortalException { 247 return getService() 248 .addTempFileEntry(groupId, folderId, folderName, fileName, 249 file, mimeType); 250 } 251 252 /** 253 * Adds a temporary file entry. It is created based on the {@link 254 * InputStream} object. 255 * 256 * <p> 257 * This allows a client to upload a file into a temporary location and 258 * manipulate its metadata prior to making it available for public usage. 259 * This is different from checking in and checking out a file entry. 260 * </p> 261 * 262 * @param groupId the primary key of the group 263 * @param folderId the primary key of the folder where the file entry will 264 eventually reside 265 * @param folderName the temporary folder's name 266 * @param fileName the file's original name 267 * @param inputStream the file's data 268 * @param mimeType the file's MIME type 269 * @return the temporary file entry 270 * @throws PortalException if the file name was invalid or if a portal 271 exception occurred 272 * @see com.liferay.portal.kernel.util.TempFileEntryUtil 273 */ 274 public static com.liferay.portal.kernel.repository.model.FileEntry addTempFileEntry( 275 long groupId, long folderId, java.lang.String folderName, 276 java.lang.String fileName, java.io.InputStream inputStream, 277 java.lang.String mimeType) 278 throws com.liferay.portal.kernel.exception.PortalException { 279 return getService() 280 .addTempFileEntry(groupId, folderId, folderName, fileName, 281 inputStream, mimeType); 282 } 283 284 /** 285 * Cancels the check out of the file entry. If a user has not checked out 286 * the specified file entry, invoking this method will result in no changes. 287 * 288 * <p> 289 * When a file entry is checked out, a PWC (private working copy) is created 290 * and the original file entry is locked. A client can make as many changes 291 * to the PWC as he desires without those changes being visible to other 292 * users. If the user is satisfied with the changes, he may elect to check 293 * in his changes, resulting in a new file version based on the PWC; the PWC 294 * will be removed and the file entry will be unlocked. If the user is not 295 * satisfied with the changes, he may elect to cancel his check out; this 296 * results in the deletion of the PWC and unlocking of the file entry. 297 * </p> 298 * 299 * @param fileEntryId the primary key of the file entry to cancel the 300 checkout 301 * @throws PortalException if the file entry could not be found 302 * @see #checkInFileEntry(long, boolean, String, ServiceContext) 303 * @see #checkOutFileEntry(long, ServiceContext) 304 */ 305 public static void cancelCheckOut(long fileEntryId) 306 throws com.liferay.portal.kernel.exception.PortalException { 307 getService().cancelCheckOut(fileEntryId); 308 } 309 310 /** 311 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 312 String, ServiceContext)} 313 */ 314 @Deprecated 315 public static void checkInFileEntry(long fileEntryId, 316 java.lang.String lockUuid) 317 throws com.liferay.portal.kernel.exception.PortalException { 318 getService().checkInFileEntry(fileEntryId, lockUuid); 319 } 320 321 /** 322 * Checks in the file entry using the lock's UUID. If a user has not checked 323 * out the specified file entry, invoking this method will result in no 324 * changes. This method is primarily used by WebDAV. 325 * 326 * <p> 327 * When a file entry is checked out, a PWC (private working copy) is created 328 * and the original file entry is locked. A client can make as many changes 329 * to the PWC as he desires without those changes being visible to other 330 * users. If the user is satisfied with the changes, he may elect to check 331 * in his changes, resulting in a new file version based on the PWC; the PWC 332 * will be removed and the file entry will be unlocked. If the user is not 333 * satisfied with the changes, he may elect to cancel his check out; this 334 * results in the deletion of the PWC and unlocking of the file entry. 335 * </p> 336 * 337 * @param fileEntryId the primary key of the file entry to check in 338 * @param lockUuid the lock's UUID 339 * @param serviceContext the service context to be applied 340 * @throws PortalException if the file entry could not be found 341 * @see #cancelCheckOut(long) 342 * @see #checkOutFileEntry(long, String, long, ServiceContext) 343 */ 344 public static void checkInFileEntry(long fileEntryId, 345 java.lang.String lockUuid, 346 com.liferay.portal.service.ServiceContext serviceContext) 347 throws com.liferay.portal.kernel.exception.PortalException { 348 getService().checkInFileEntry(fileEntryId, lockUuid, serviceContext); 349 } 350 351 /** 352 * Checks in the file entry. If a user has not checked out the specified 353 * file entry, invoking this method will result in no changes. 354 * 355 * <p> 356 * When a file entry is checked out, a PWC (private working copy) is created 357 * and the original file entry is locked. A client can make as many changes 358 * to the PWC as he desires without those changes being visible to other 359 * users. If the user is satisfied with the changes, he may elect to check 360 * in his changes, resulting in a new file version based on the PWC; the PWC 361 * will be removed and the file entry will be unlocked. If the user is not 362 * satisfied with the changes, he may elect to cancel his check out; this 363 * results in the deletion of the PWC and unlocking of the file entry. 364 * </p> 365 * 366 * @param fileEntryId the primary key of the file entry to check in 367 * @param majorVersion whether the new file version is a major version 368 * @param changeLog the file's version change log 369 * @param serviceContext the service context to be applied 370 * @throws PortalException if the file entry could not be found 371 * @see #cancelCheckOut(long) 372 * @see #checkOutFileEntry(long, ServiceContext) 373 */ 374 public static void checkInFileEntry(long fileEntryId, boolean majorVersion, 375 java.lang.String changeLog, 376 com.liferay.portal.service.ServiceContext serviceContext) 377 throws com.liferay.portal.kernel.exception.PortalException { 378 getService() 379 .checkInFileEntry(fileEntryId, majorVersion, changeLog, 380 serviceContext); 381 } 382 383 /** 384 * Checks out the file entry. This method is primarily used by WebDAV. 385 * 386 * <p> 387 * When a file entry is checked out, a PWC (private working copy) is created 388 * and the original file entry is locked. A client can make as many changes 389 * to the PWC as he desires without those changes being visible to other 390 * users. If the user is satisfied with the changes, he may elect to check 391 * in his changes, resulting in a new file version based on the PWC; the PWC 392 * will be removed and the file entry will be unlocked. If the user is not 393 * satisfied with the changes, he may elect to cancel his check out; this 394 * results in the deletion of the PWC and unlocking of the file entry. 395 * </p> 396 * 397 * @param fileEntryId the file entry to check out 398 * @param owner the owner string for the checkout (optionally 399 <code>null</code>) 400 * @param expirationTime the time in milliseconds before the lock expires. 401 If the value is <code>0</code>, the default expiration time will 402 be used from <code>portal.properties>. 403 * @param serviceContext the service context to be applied 404 * @return the file entry 405 * @throws PortalException if the file entry could not be found 406 * @see #cancelCheckOut(long) 407 * @see #checkInFileEntry(long, String) 408 */ 409 public static com.liferay.portal.kernel.repository.model.FileEntry checkOutFileEntry( 410 long fileEntryId, java.lang.String owner, long expirationTime, 411 com.liferay.portal.service.ServiceContext serviceContext) 412 throws com.liferay.portal.kernel.exception.PortalException { 413 return getService() 414 .checkOutFileEntry(fileEntryId, owner, expirationTime, 415 serviceContext); 416 } 417 418 /** 419 * Check out a file entry. 420 * 421 * <p> 422 * When a file entry is checked out, a PWC (private working copy) is created 423 * and the original file entry is locked. A client can make as many changes 424 * to the PWC as he desires without those changes being visible to other 425 * users. If the user is satisfied with the changes, he may elect to check 426 * in his changes, resulting in a new file version based on the PWC; the PWC 427 * will be removed and the file entry will be unlocked. If the user is not 428 * satisfied with the changes, he may elect to cancel his check out; this 429 * results in the deletion of the PWC and unlocking of the file entry. 430 * </p> 431 * 432 * @param fileEntryId the file entry to check out 433 * @param serviceContext the service context to be applied 434 * @throws PortalException if the file entry could not be found 435 * @see #cancelCheckOut(long) 436 * @see #checkInFileEntry(long, boolean, String, ServiceContext) 437 */ 438 public static void checkOutFileEntry(long fileEntryId, 439 com.liferay.portal.service.ServiceContext serviceContext) 440 throws com.liferay.portal.kernel.exception.PortalException { 441 getService().checkOutFileEntry(fileEntryId, serviceContext); 442 } 443 444 /** 445 * Performs a deep copy of the folder. 446 * 447 * @param repositoryId the primary key of the repository 448 * @param sourceFolderId the primary key of the folder to copy 449 * @param parentFolderId the primary key of the new folder's parent folder 450 * @param name the new folder's name 451 * @param description the new folder's description 452 * @param serviceContext the service context to be applied 453 * @return the folder 454 * @throws PortalException if the source folder or the new parent folder 455 could not be found or if the new folder's information was invalid 456 */ 457 public static com.liferay.portal.kernel.repository.model.Folder copyFolder( 458 long repositoryId, long sourceFolderId, long parentFolderId, 459 java.lang.String name, java.lang.String description, 460 com.liferay.portal.service.ServiceContext serviceContext) 461 throws com.liferay.portal.kernel.exception.PortalException { 462 return getService() 463 .copyFolder(repositoryId, sourceFolderId, parentFolderId, 464 name, description, serviceContext); 465 } 466 467 /** 468 * Deletes the file entry with the primary key. 469 * 470 * @param fileEntryId the primary key of the file entry 471 * @throws PortalException if the file entry could not be found 472 */ 473 public static void deleteFileEntry(long fileEntryId) 474 throws com.liferay.portal.kernel.exception.PortalException { 475 getService().deleteFileEntry(fileEntryId); 476 } 477 478 /** 479 * Deletes the file entry with the title in the folder. 480 * 481 * @param repositoryId the primary key of the repository 482 * @param folderId the primary key of the file entry's parent folder 483 * @param title the file entry's title 484 * @throws PortalException if the file entry could not be found 485 */ 486 public static void deleteFileEntryByTitle(long repositoryId, long folderId, 487 java.lang.String title) 488 throws com.liferay.portal.kernel.exception.PortalException { 489 getService().deleteFileEntryByTitle(repositoryId, folderId, title); 490 } 491 492 /** 493 * Deletes the file shortcut with the primary key. This method is only 494 * supported by the Liferay repository. 495 * 496 * @param fileShortcutId the primary key of the file shortcut 497 * @throws PortalException if the file shortcut could not be found 498 */ 499 public static void deleteFileShortcut(long fileShortcutId) 500 throws com.liferay.portal.kernel.exception.PortalException { 501 getService().deleteFileShortcut(fileShortcutId); 502 } 503 504 /** 505 * Deletes the file version. File versions can only be deleted if it is 506 * approved and there are other approved file versions available. This 507 * method is only supported by the Liferay repository. 508 * 509 * @param fileEntryId the primary key of the file entry 510 * @param version the version label of the file version 511 * @throws PortalException if the file version could not be found or invalid 512 */ 513 public static void deleteFileVersion(long fileEntryId, 514 java.lang.String version) 515 throws com.liferay.portal.kernel.exception.PortalException { 516 getService().deleteFileVersion(fileEntryId, version); 517 } 518 519 /** 520 * Deletes the folder with the primary key and all of its subfolders and 521 * file entries. 522 * 523 * @param folderId the primary key of the folder 524 * @throws PortalException if the folder could not be found 525 */ 526 public static void deleteFolder(long folderId) 527 throws com.liferay.portal.kernel.exception.PortalException { 528 getService().deleteFolder(folderId); 529 } 530 531 /** 532 * Deletes the folder with the name in the parent folder and all of its 533 * subfolders and file entries. 534 * 535 * @param repositoryId the primary key of the repository 536 * @param parentFolderId the primary key of the folder's parent folder 537 * @param name the folder's name 538 * @throws PortalException if the folder could not be found 539 */ 540 public static void deleteFolder(long repositoryId, long parentFolderId, 541 java.lang.String name) 542 throws com.liferay.portal.kernel.exception.PortalException { 543 getService().deleteFolder(repositoryId, parentFolderId, name); 544 } 545 546 /** 547 * Deletes the temporary file entry. 548 * 549 * @param groupId the primary key of the group 550 * @param folderId the primary key of the folder where the file entry was 551 eventually to reside 552 * @param folderName the temporary folder's name 553 * @param fileName the file's original name 554 * @throws PortalException if the file name was invalid 555 * @see com.liferay.portal.kernel.util.TempFileEntryUtil 556 */ 557 public static void deleteTempFileEntry(long groupId, long folderId, 558 java.lang.String folderName, java.lang.String fileName) 559 throws com.liferay.portal.kernel.exception.PortalException { 560 getService().deleteTempFileEntry(groupId, folderId, folderName, fileName); 561 } 562 563 /** 564 * Returns the Spring bean ID for this bean. 565 * 566 * @return the Spring bean ID for this bean 567 */ 568 public static java.lang.String getBeanIdentifier() { 569 return getService().getBeanIdentifier(); 570 } 571 572 /** 573 * Returns all the file entries in the folder. 574 * 575 * @param repositoryId the primary key of the file entry's repository 576 * @param folderId the primary key of the file entry's folder 577 * @return the file entries in the folder 578 * @throws PortalException if the folder could not be found 579 */ 580 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 581 long repositoryId, long folderId) 582 throws com.liferay.portal.kernel.exception.PortalException { 583 return getService().getFileEntries(repositoryId, folderId); 584 } 585 586 /** 587 * Returns the file entries with the file entry type in the folder. 588 * 589 * @param repositoryId the primary key of the file entry's repository 590 * @param folderId the primary key of the file entry's folder 591 * @param fileEntryTypeId the primary key of the file entry type 592 * @return the file entries with the file entry type in the folder 593 * @throws PortalException if the folder could not be found 594 */ 595 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 596 long repositoryId, long folderId, long fileEntryTypeId) 597 throws com.liferay.portal.kernel.exception.PortalException { 598 return getService() 599 .getFileEntries(repositoryId, folderId, fileEntryTypeId); 600 } 601 602 /** 603 * Returns a range of all the file entries with the file entry type in the 604 * folder. 605 * 606 * @param repositoryId the primary key of the file entry's repository 607 * @param folderId the primary key of the file entry's folder 608 * @param fileEntryTypeId the primary key of the file entry type 609 * @param start the lower bound of the range of results 610 * @param end the upper bound of the range of results (not inclusive) 611 * @return the file entries in the folder 612 * @throws PortalException if the folder could not be found 613 */ 614 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 615 long repositoryId, long folderId, long fileEntryTypeId, int start, 616 int end) throws com.liferay.portal.kernel.exception.PortalException { 617 return getService() 618 .getFileEntries(repositoryId, folderId, fileEntryTypeId, 619 start, end); 620 } 621 622 /** 623 * Returns an ordered range of all the file entries with the file entry type 624 * in the folder. 625 * 626 * @param repositoryId the primary key of the repository 627 * @param folderId the primary key of the folder 628 * @param fileEntryTypeId the primary key of the file entry type 629 * @param start the lower bound of the range of results 630 * @param end the upper bound of the range of results (not inclusive) 631 * @param obc the comparator to order the results by (optionally 632 <code>null</code>) 633 * @return the range of file entries with the file entry type in the folder 634 ordered by <code>null</code> 635 * @throws PortalException if the folder could not be found 636 */ 637 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 638 long repositoryId, long folderId, long fileEntryTypeId, int start, 639 int end, 640 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 641 throws com.liferay.portal.kernel.exception.PortalException { 642 return getService() 643 .getFileEntries(repositoryId, folderId, fileEntryTypeId, 644 start, end, obc); 645 } 646 647 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 648 long repositoryId, long folderId, java.lang.String[] mimeTypes) 649 throws com.liferay.portal.kernel.exception.PortalException { 650 return getService().getFileEntries(repositoryId, folderId, mimeTypes); 651 } 652 653 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 654 long repositoryId, long folderId, java.lang.String[] mimeTypes, 655 int start, int end, 656 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 657 throws com.liferay.portal.kernel.exception.PortalException { 658 return getService() 659 .getFileEntries(repositoryId, folderId, mimeTypes, start, 660 end, obc); 661 } 662 663 /** 664 * Returns a range of all the file entries in the folder. 665 * 666 * <p> 667 * Useful when paginating results. Returns a maximum of <code>end - 668 * start</code> instances. <code>start</code> and <code>end</code> are not 669 * primary keys, they are indexes in the result set. Thus, <code>0</code> 670 * refers to the first result in the set. Setting both <code>start</code> 671 * and <code>end</code> to {@link 672 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 673 * result set. 674 * </p> 675 * 676 * @param repositoryId the primary key of the file entry's repository 677 * @param folderId the primary key of the file entry's folder 678 * @param start the lower bound of the range of results 679 * @param end the upper bound of the range of results (not inclusive) 680 * @return the range of file entries in the folder 681 * @throws PortalException if the folder could not be found 682 */ 683 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 684 long repositoryId, long folderId, int start, int end) 685 throws com.liferay.portal.kernel.exception.PortalException { 686 return getService().getFileEntries(repositoryId, folderId, start, end); 687 } 688 689 /** 690 * Returns an ordered range of all the file entries in the folder. 691 * 692 * <p> 693 * Useful when paginating results. Returns a maximum of <code>end - 694 * start</code> instances. <code>start</code> and <code>end</code> are not 695 * primary keys, they are indexes in the result set. Thus, <code>0</code> 696 * refers to the first result in the set. Setting both <code>start</code> 697 * and <code>end</code> to {@link 698 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 699 * result set. 700 * </p> 701 * 702 * @param repositoryId the primary key of the file entry's repository 703 * @param folderId the primary key of the file entry's folder 704 * @param start the lower bound of the range of results 705 * @param end the upper bound of the range of results (not inclusive) 706 * @param obc the comparator to order the file entries (optionally 707 <code>null</code>) 708 * @return the range of file entries in the folder ordered by comparator 709 <code>obc</code> 710 * @throws PortalException if the folder could not be found 711 */ 712 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 713 long repositoryId, long folderId, int start, int end, 714 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 715 throws com.liferay.portal.kernel.exception.PortalException { 716 return getService() 717 .getFileEntries(repositoryId, folderId, start, end, obc); 718 } 719 720 /** 721 * Returns a range of all the file entries and shortcuts in the folder. 722 * 723 * <p> 724 * Useful when paginating results. Returns a maximum of <code>end - 725 * start</code> instances. <code>start</code> and <code>end</code> are not 726 * primary keys, they are indexes in the result set. Thus, <code>0</code> 727 * refers to the first result in the set. Setting both <code>start</code> 728 * and <code>end</code> to {@link 729 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 730 * result set. 731 * </p> 732 * 733 * @param repositoryId the primary key of the repository 734 * @param folderId the primary key of the folder 735 * @param status the workflow status 736 * @param start the lower bound of the range of results 737 * @param end the upper bound of the range of results (not inclusive) 738 * @return the range of file entries and shortcuts in the folder 739 * @throws PortalException if the folder could not be found 740 */ 741 public static java.util.List<java.lang.Object> getFileEntriesAndFileShortcuts( 742 long repositoryId, long folderId, int status, int start, int end) 743 throws com.liferay.portal.kernel.exception.PortalException { 744 return getService() 745 .getFileEntriesAndFileShortcuts(repositoryId, folderId, 746 status, start, end); 747 } 748 749 /** 750 * Returns the number of file entries and shortcuts in the folder. 751 * 752 * @param repositoryId the primary key of the repository 753 * @param folderId the primary key of the folder 754 * @param status the workflow status 755 * @return the number of file entries and shortcuts in the folder 756 * @throws PortalException if the folder ould not be found 757 */ 758 public static int getFileEntriesAndFileShortcutsCount(long repositoryId, 759 long folderId, int status) 760 throws com.liferay.portal.kernel.exception.PortalException { 761 return getService() 762 .getFileEntriesAndFileShortcutsCount(repositoryId, folderId, 763 status); 764 } 765 766 /** 767 * Returns the number of file entries and shortcuts in the folder. 768 * 769 * @param repositoryId the primary key of the repository 770 * @param folderId the primary key of the folder 771 * @param status the workflow status 772 * @param mimeTypes allowed media types 773 * @return the number of file entries and shortcuts in the folder 774 * @throws PortalException if the folder ould not be found 775 */ 776 public static int getFileEntriesAndFileShortcutsCount(long repositoryId, 777 long folderId, int status, java.lang.String[] mimeTypes) 778 throws com.liferay.portal.kernel.exception.PortalException { 779 return getService() 780 .getFileEntriesAndFileShortcutsCount(repositoryId, folderId, 781 status, mimeTypes); 782 } 783 784 /** 785 * Returns the number of file entries in the folder. 786 * 787 * @param repositoryId the primary key of the file entry's repository 788 * @param folderId the primary key of the file entry's folder 789 * @return the number of file entries in the folder 790 * @throws PortalException if the folder could not be found 791 */ 792 public static int getFileEntriesCount(long repositoryId, long folderId) 793 throws com.liferay.portal.kernel.exception.PortalException { 794 return getService().getFileEntriesCount(repositoryId, folderId); 795 } 796 797 /** 798 * Returns the number of file entries with the file entry type in the 799 * folder. 800 * 801 * @param repositoryId the primary key of the file entry's repository 802 * @param folderId the primary key of the file entry's folder 803 * @param fileEntryTypeId the primary key of the file entry type 804 * @return the number of file entries with the file entry type in the folder 805 * @throws PortalException if the folder could not be found 806 */ 807 public static int getFileEntriesCount(long repositoryId, long folderId, 808 long fileEntryTypeId) 809 throws com.liferay.portal.kernel.exception.PortalException { 810 return getService() 811 .getFileEntriesCount(repositoryId, folderId, fileEntryTypeId); 812 } 813 814 public static int getFileEntriesCount(long repositoryId, long folderId, 815 java.lang.String[] mimeTypes) 816 throws com.liferay.portal.kernel.exception.PortalException { 817 return getService() 818 .getFileEntriesCount(repositoryId, folderId, mimeTypes); 819 } 820 821 /** 822 * Returns the file entry with the primary key. 823 * 824 * @param fileEntryId the primary key of the file entry 825 * @return the file entry with the primary key 826 * @throws PortalException if the file entry could not be found 827 */ 828 public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntry( 829 long fileEntryId) 830 throws com.liferay.portal.kernel.exception.PortalException { 831 return getService().getFileEntry(fileEntryId); 832 } 833 834 /** 835 * Returns the file entry with the title in the folder. 836 * 837 * @param groupId the primary key of the file entry's group 838 * @param folderId the primary key of the file entry's folder 839 * @param title the file entry's title 840 * @return the file entry with the title in the folder 841 * @throws PortalException if the file entry could not be found 842 */ 843 public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntry( 844 long groupId, long folderId, java.lang.String title) 845 throws com.liferay.portal.kernel.exception.PortalException { 846 return getService().getFileEntry(groupId, folderId, title); 847 } 848 849 /** 850 * Returns the file entry with the UUID and group. 851 * 852 * @param uuid the file entry's UUID 853 * @param groupId the primary key of the file entry's group 854 * @return the file entry with the UUID and group 855 * @throws PortalException if the file entry could not be found 856 */ 857 public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntryByUuidAndGroupId( 858 java.lang.String uuid, long groupId) 859 throws com.liferay.portal.kernel.exception.PortalException { 860 return getService().getFileEntryByUuidAndGroupId(uuid, groupId); 861 } 862 863 /** 864 * Returns the file shortcut with the primary key. This method is only 865 * supported by the Liferay repository. 866 * 867 * @param fileShortcutId the primary key of the file shortcut 868 * @return the file shortcut with the primary key 869 * @throws PortalException if the file shortcut could not be found 870 */ 871 public static com.liferay.portlet.documentlibrary.model.DLFileShortcut getFileShortcut( 872 long fileShortcutId) 873 throws com.liferay.portal.kernel.exception.PortalException { 874 return getService().getFileShortcut(fileShortcutId); 875 } 876 877 /** 878 * Returns the file version with the primary key. 879 * 880 * @param fileVersionId the primary key of the file version 881 * @return the file version with the primary key 882 * @throws PortalException if the file version could not be found 883 */ 884 public static com.liferay.portal.kernel.repository.model.FileVersion getFileVersion( 885 long fileVersionId) 886 throws com.liferay.portal.kernel.exception.PortalException { 887 return getService().getFileVersion(fileVersionId); 888 } 889 890 /** 891 * Returns the folder with the primary key. 892 * 893 * @param folderId the primary key of the folder 894 * @return the folder with the primary key 895 * @throws PortalException if the folder could not be found 896 */ 897 public static com.liferay.portal.kernel.repository.model.Folder getFolder( 898 long folderId) 899 throws com.liferay.portal.kernel.exception.PortalException { 900 return getService().getFolder(folderId); 901 } 902 903 /** 904 * Returns the folder with the name in the parent folder. 905 * 906 * @param repositoryId the primary key of the folder's repository 907 * @param parentFolderId the primary key of the folder's parent folder 908 * @param name the folder's name 909 * @return the folder with the name in the parent folder 910 * @throws PortalException if the folder could not be found 911 */ 912 public static com.liferay.portal.kernel.repository.model.Folder getFolder( 913 long repositoryId, long parentFolderId, java.lang.String name) 914 throws com.liferay.portal.kernel.exception.PortalException { 915 return getService().getFolder(repositoryId, parentFolderId, name); 916 } 917 918 /** 919 * Returns all immediate subfolders of the parent folder. 920 * 921 * @param repositoryId the primary key of the folder's repository 922 * @param parentFolderId the primary key of the folder's parent folder 923 * @return the immediate subfolders of the parent folder 924 * @throws PortalException if the parent folder could not be found 925 */ 926 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 927 long repositoryId, long parentFolderId) 928 throws com.liferay.portal.kernel.exception.PortalException { 929 return getService().getFolders(repositoryId, parentFolderId); 930 } 931 932 /** 933 * Returns all immediate subfolders of the parent folder, optionally 934 * including mount folders for third-party repositories. 935 * 936 * @param repositoryId the primary key of the folder's repository 937 * @param parentFolderId the primary key of the folder's parent folder 938 * @param includeMountFolders whether to include mount folders for 939 third-party repositories 940 * @return the immediate subfolders of the parent folder 941 * @throws PortalException if the parent folder could not be found 942 */ 943 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 944 long repositoryId, long parentFolderId, boolean includeMountFolders) 945 throws com.liferay.portal.kernel.exception.PortalException { 946 return getService() 947 .getFolders(repositoryId, parentFolderId, includeMountFolders); 948 } 949 950 /** 951 * Returns a range of all the immediate subfolders of the parent folder, 952 * optionally including mount folders for third-party repositories. 953 * 954 * <p> 955 * Useful when paginating results. Returns a maximum of <code>end - 956 * start</code> instances. <code>start</code> and <code>end</code> are not 957 * primary keys, they are indexes in the result set. Thus, <code>0</code> 958 * refers to the first result in the set. Setting both <code>start</code> 959 * and <code>end</code> to {@link 960 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 961 * result set. 962 * </p> 963 * 964 * @param repositoryId the primary key of the folder's repository 965 * @param parentFolderId the primary key of the folder's parent folder 966 * @param includeMountFolders whether to include mount folders for 967 third-party repositories 968 * @param start the lower bound of the range of results 969 * @param end the upper bound of the range of results (not inclusive) 970 * @return the range of immediate subfolders of the parent folder 971 * @throws PortalException if the parent folder could not be found 972 */ 973 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 974 long repositoryId, long parentFolderId, boolean includeMountFolders, 975 int start, int end) 976 throws com.liferay.portal.kernel.exception.PortalException { 977 return getService() 978 .getFolders(repositoryId, parentFolderId, 979 includeMountFolders, start, end); 980 } 981 982 /** 983 * Returns an ordered range of all the immediate subfolders of the parent 984 * folder. 985 * 986 * <p> 987 * Useful when paginating results. Returns a maximum of <code>end - 988 * start</code> instances. <code>start</code> and <code>end</code> are not 989 * primary keys, they are indexes in the result set. Thus, <code>0</code> 990 * refers to the first result in the set. Setting both <code>start</code> 991 * and <code>end</code> to {@link 992 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 993 * result set. 994 * </p> 995 * 996 * @param repositoryId the primary key of the folder's repository 997 * @param parentFolderId the primary key of the folder's parent folder 998 * @param includeMountFolders whether to include mount folders for 999 third-party repositories 1000 * @param start the lower bound of the range of results 1001 * @param end the upper bound of the range of results (not inclusive) 1002 * @param obc the comparator to order the folders (optionally 1003 <code>null</code>) 1004 * @return the range of immediate subfolders of the parent folder ordered by 1005 comparator <code>obc</code> 1006 * @throws PortalException if the parent folder could not be found 1007 */ 1008 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1009 long repositoryId, long parentFolderId, boolean includeMountFolders, 1010 int start, int end, 1011 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1012 throws com.liferay.portal.kernel.exception.PortalException { 1013 return getService() 1014 .getFolders(repositoryId, parentFolderId, 1015 includeMountFolders, start, end, obc); 1016 } 1017 1018 /** 1019 * Returns a range of all the immediate subfolders of the parent folder. 1020 * 1021 * <p> 1022 * Useful when paginating results. Returns a maximum of <code>end - 1023 * start</code> instances. <code>start</code> and <code>end</code> are not 1024 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1025 * refers to the first result in the set. Setting both <code>start</code> 1026 * and <code>end</code> to {@link 1027 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1028 * result set. 1029 * </p> 1030 * 1031 * @param repositoryId the primary key of the folder's repository 1032 * @param parentFolderId the primary key of the folder's parent folder 1033 * @param start the lower bound of the range of results 1034 * @param end the upper bound of the range of results (not inclusive) 1035 * @return the range of immediate subfolders of the parent folder 1036 * @throws PortalException if the parent folder could not be found 1037 */ 1038 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1039 long repositoryId, long parentFolderId, int start, int end) 1040 throws com.liferay.portal.kernel.exception.PortalException { 1041 return getService().getFolders(repositoryId, parentFolderId, start, end); 1042 } 1043 1044 /** 1045 * Returns an ordered range of all the immediate subfolders of the parent 1046 * folder. 1047 * 1048 * <p> 1049 * Useful when paginating results. Returns a maximum of <code>end - 1050 * start</code> instances. <code>start</code> and <code>end</code> are not 1051 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1052 * refers to the first result in the set. Setting both <code>start</code> 1053 * and <code>end</code> to {@link 1054 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1055 * result set. 1056 * </p> 1057 * 1058 * @param repositoryId the primary key of the folder's repository 1059 * @param parentFolderId the primary key of the folder's parent folder 1060 * @param start the lower bound of the range of results 1061 * @param end the upper bound of the range of results (not inclusive) 1062 * @param obc the comparator to order the folders (optionally 1063 <code>null</code>) 1064 * @return the range of immediate subfolders of the parent folder ordered by 1065 comparator <code>obc</code> 1066 * @throws PortalException if the parent folder could not be found 1067 */ 1068 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1069 long repositoryId, long parentFolderId, int start, int end, 1070 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1071 throws com.liferay.portal.kernel.exception.PortalException { 1072 return getService() 1073 .getFolders(repositoryId, parentFolderId, start, end, obc); 1074 } 1075 1076 /** 1077 * Returns an ordered range of all the immediate subfolders of the parent 1078 * folder. 1079 * 1080 * <p> 1081 * Useful when paginating results. Returns a maximum of <code>end - 1082 * start</code> instances. <code>start</code> and <code>end</code> are not 1083 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1084 * refers to the first result in the set. Setting both <code>start</code> 1085 * and <code>end</code> to {@link 1086 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1087 * result set. 1088 * </p> 1089 * 1090 * @param repositoryId the primary key of the folder's repository 1091 * @param parentFolderId the primary key of the folder's parent folder 1092 * @param status the workflow status 1093 * @param includeMountFolders whether to include mount folders for 1094 third-party repositories 1095 * @param start the lower bound of the range of results 1096 * @param end the upper bound of the range of results (not inclusive) 1097 * @param obc the comparator to order the folders (optionally 1098 <code>null</code>) 1099 * @return the range of immediate subfolders of the parent folder ordered by 1100 comparator <code>obc</code> 1101 * @throws PortalException if the parent folder could not be found 1102 */ 1103 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1104 long repositoryId, long parentFolderId, int status, 1105 boolean includeMountFolders, int start, int end, 1106 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1107 throws com.liferay.portal.kernel.exception.PortalException { 1108 return getService() 1109 .getFolders(repositoryId, parentFolderId, status, 1110 includeMountFolders, start, end, obc); 1111 } 1112 1113 /** 1114 * Returns a range of all the immediate subfolders, file entries, and file 1115 * shortcuts in the parent folder. 1116 * 1117 * <p> 1118 * Useful when paginating results. Returns a maximum of <code>end - 1119 * start</code> instances. <code>start</code> and <code>end</code> are not 1120 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1121 * refers to the first result in the set. Setting both <code>start</code> 1122 * and <code>end</code> to {@link 1123 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1124 * result set. 1125 * </p> 1126 * 1127 * @param repositoryId the primary key of the repository 1128 * @param folderId the primary key of the parent folder 1129 * @param status the workflow status 1130 * @param includeMountFolders whether to include mount folders for 1131 third-party repositories 1132 * @param start the lower bound of the range of results 1133 * @param end the upper bound of the range of results (not inclusive) 1134 * @return the range of immediate subfolders, file entries, and file 1135 shortcuts in the parent folder ordered by comparator 1136 <code>obc</code> 1137 * @throws PortalException if the parent folder could not be found 1138 */ 1139 public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts( 1140 long repositoryId, long folderId, int status, 1141 boolean includeMountFolders, int start, int end) 1142 throws com.liferay.portal.kernel.exception.PortalException { 1143 return getService() 1144 .getFoldersAndFileEntriesAndFileShortcuts(repositoryId, 1145 folderId, status, includeMountFolders, start, end); 1146 } 1147 1148 /** 1149 * Returns an ordered range of all the immediate subfolders, file entries, 1150 * and file shortcuts in the parent folder. 1151 * 1152 * <p> 1153 * Useful when paginating results. Returns a maximum of <code>end - 1154 * start</code> instances. <code>start</code> and <code>end</code> are not 1155 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1156 * refers to the first result in the set. Setting both <code>start</code> 1157 * and <code>end</code> to {@link 1158 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1159 * result set. 1160 * </p> 1161 * 1162 * @param repositoryId the primary key of the repository 1163 * @param folderId the primary key of the parent folder 1164 * @param status the workflow status 1165 * @param includeMountFolders whether to include mount folders for 1166 third-party repositories 1167 * @param start the lower bound of the range of results 1168 * @param end the upper bound of the range of results (not inclusive) 1169 * @param obc the comparator to order the results (optionally 1170 <code>null</code>) 1171 * @return the range of immediate subfolders, file entries, and file 1172 shortcuts in the parent folder ordered by comparator 1173 <code>obc</code> 1174 * @throws PortalException if the parent folder could not be found 1175 */ 1176 public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts( 1177 long repositoryId, long folderId, int status, 1178 boolean includeMountFolders, int start, int end, 1179 com.liferay.portal.kernel.util.OrderByComparator<?> obc) 1180 throws com.liferay.portal.kernel.exception.PortalException { 1181 return getService() 1182 .getFoldersAndFileEntriesAndFileShortcuts(repositoryId, 1183 folderId, status, includeMountFolders, start, end, obc); 1184 } 1185 1186 public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts( 1187 long repositoryId, long folderId, int status, 1188 java.lang.String[] mimeTypes, boolean includeMountFolders, int start, 1189 int end, com.liferay.portal.kernel.util.OrderByComparator<?> obc) 1190 throws com.liferay.portal.kernel.exception.PortalException { 1191 return getService() 1192 .getFoldersAndFileEntriesAndFileShortcuts(repositoryId, 1193 folderId, status, mimeTypes, includeMountFolders, start, end, obc); 1194 } 1195 1196 /** 1197 * Returns the number of immediate subfolders, file entries, and file 1198 * shortcuts in the parent folder. 1199 * 1200 * @param repositoryId the primary key of the repository 1201 * @param folderId the primary key of the parent folder 1202 * @param status the workflow status 1203 * @param includeMountFolders whether to include mount folders for 1204 third-party repositories 1205 * @return the number of immediate subfolders, file entries, and file 1206 shortcuts in the parent folder 1207 * @throws PortalException if the folder could not be found 1208 */ 1209 public static int getFoldersAndFileEntriesAndFileShortcutsCount( 1210 long repositoryId, long folderId, int status, 1211 boolean includeMountFolders) 1212 throws com.liferay.portal.kernel.exception.PortalException { 1213 return getService() 1214 .getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId, 1215 folderId, status, includeMountFolders); 1216 } 1217 1218 public static int getFoldersAndFileEntriesAndFileShortcutsCount( 1219 long repositoryId, long folderId, int status, 1220 java.lang.String[] mimeTypes, boolean includeMountFolders) 1221 throws com.liferay.portal.kernel.exception.PortalException { 1222 return getService() 1223 .getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId, 1224 folderId, status, mimeTypes, includeMountFolders); 1225 } 1226 1227 /** 1228 * Returns the number of immediate subfolders of the parent folder. 1229 * 1230 * @param repositoryId the primary key of the folder's repository 1231 * @param parentFolderId the primary key of the folder's parent folder 1232 * @return the number of immediate subfolders of the parent folder 1233 * @throws PortalException if the parent folder could not be found 1234 */ 1235 public static int getFoldersCount(long repositoryId, long parentFolderId) 1236 throws com.liferay.portal.kernel.exception.PortalException { 1237 return getService().getFoldersCount(repositoryId, parentFolderId); 1238 } 1239 1240 /** 1241 * Returns the number of immediate subfolders of the parent folder, 1242 * optionally including mount folders for third-party repositories. 1243 * 1244 * @param repositoryId the primary key of the folder's repository 1245 * @param parentFolderId the primary key of the folder's parent folder 1246 * @param includeMountFolders whether to include mount folders for 1247 third-party repositories 1248 * @return the number of immediate subfolders of the parent folder 1249 * @throws PortalException if the parent folder could not be found 1250 */ 1251 public static int getFoldersCount(long repositoryId, long parentFolderId, 1252 boolean includeMountFolders) 1253 throws com.liferay.portal.kernel.exception.PortalException { 1254 return getService() 1255 .getFoldersCount(repositoryId, parentFolderId, 1256 includeMountFolders); 1257 } 1258 1259 /** 1260 * Returns the number of immediate subfolders of the parent folder, 1261 * optionally including mount folders for third-party repositories. 1262 * 1263 * @param repositoryId the primary key of the folder's repository 1264 * @param parentFolderId the primary key of the folder's parent folder 1265 * @param status the workflow status 1266 * @param includeMountFolders whether to include mount folders for 1267 third-party repositories 1268 * @return the number of immediate subfolders of the parent folder 1269 * @throws PortalException if the parent folder could not be found 1270 */ 1271 public static int getFoldersCount(long repositoryId, long parentFolderId, 1272 int status, boolean includeMountFolders) 1273 throws com.liferay.portal.kernel.exception.PortalException { 1274 return getService() 1275 .getFoldersCount(repositoryId, parentFolderId, status, 1276 includeMountFolders); 1277 } 1278 1279 /** 1280 * Returns the number of immediate subfolders and file entries across the 1281 * folders. 1282 * 1283 * @param repositoryId the primary key of the repository 1284 * @param folderIds the primary keys of folders from which to count 1285 immediate subfolders and file entries 1286 * @param status the workflow status 1287 * @return the number of immediate subfolders and file entries across the 1288 folders 1289 * @throws PortalException if the repository could not be found 1290 */ 1291 public static int getFoldersFileEntriesCount(long repositoryId, 1292 java.util.List<java.lang.Long> folderIds, int status) 1293 throws com.liferay.portal.kernel.exception.PortalException { 1294 return getService() 1295 .getFoldersFileEntriesCount(repositoryId, folderIds, status); 1296 } 1297 1298 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1299 long groupId, long userId, long rootFolderId, 1300 java.lang.String[] mimeTypes, int status, int start, int end, 1301 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 1302 throws com.liferay.portal.kernel.exception.PortalException { 1303 return getService() 1304 .getGroupFileEntries(groupId, userId, rootFolderId, 1305 mimeTypes, status, start, end, obc); 1306 } 1307 1308 /** 1309 * Returns an ordered range of all the file entries in the group starting at 1310 * the root folder that are stored within the Liferay repository. This 1311 * method is primarily used to search for recently modified file entries. It 1312 * can be limited to the file entries modified by a given user. 1313 * 1314 * <p> 1315 * Useful when paginating results. Returns a maximum of <code>end - 1316 * start</code> instances. <code>start</code> and <code>end</code> are not 1317 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1318 * refers to the first result in the set. Setting both <code>start</code> 1319 * and <code>end</code> to {@link 1320 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1321 * result set. 1322 * </p> 1323 * 1324 * @param groupId the primary key of the group 1325 * @param userId the primary key of the user who created the file 1326 (optionally <code>0</code>) 1327 * @param rootFolderId the primary key of the root folder to begin the 1328 search 1329 * @param start the lower bound of the range of results 1330 * @param end the upper bound of the range of results (not inclusive) 1331 * @return the range of matching file entries ordered by date modified 1332 * @throws PortalException if the group could not be found 1333 */ 1334 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1335 long groupId, long userId, long rootFolderId, int start, int end) 1336 throws com.liferay.portal.kernel.exception.PortalException { 1337 return getService() 1338 .getGroupFileEntries(groupId, userId, rootFolderId, start, 1339 end); 1340 } 1341 1342 /** 1343 * Returns an ordered range of all the file entries in the group starting at 1344 * the root folder that are stored within the Liferay repository. This 1345 * method is primarily used to search for recently modified file entries. It 1346 * can be limited to the file entries modified by a given user. 1347 * 1348 * <p> 1349 * Useful when paginating results. Returns a maximum of <code>end - 1350 * start</code> instances. <code>start</code> and <code>end</code> are not 1351 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1352 * refers to the first result in the set. Setting both <code>start</code> 1353 * and <code>end</code> to {@link 1354 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1355 * result set. 1356 * </p> 1357 * 1358 * @param groupId the primary key of the group 1359 * @param userId the primary key of the user who created the file 1360 (optionally <code>0</code>) 1361 * @param rootFolderId the primary key of the root folder to begin the 1362 search 1363 * @param start the lower bound of the range of results 1364 * @param end the upper bound of the range of results (not inclusive) 1365 * @param obc the comparator to order the file entries (optionally 1366 <code>null</code>) 1367 * @return the range of matching file entries ordered by comparator 1368 <code>obc</code> 1369 * @throws PortalException if the group could not be found 1370 */ 1371 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1372 long groupId, long userId, long rootFolderId, int start, int end, 1373 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 1374 throws com.liferay.portal.kernel.exception.PortalException { 1375 return getService() 1376 .getGroupFileEntries(groupId, userId, rootFolderId, start, 1377 end, obc); 1378 } 1379 1380 /** 1381 * Returns an ordered range of all the file entries in the group starting at 1382 * the repository default parent folder that are stored within the Liferay 1383 * repository. This method is primarily used to search for recently modified 1384 * file entries. It can be limited to the file entries modified by a given 1385 * user. 1386 * 1387 * <p> 1388 * Useful when paginating results. Returns a maximum of <code>end - 1389 * start</code> instances. <code>start</code> and <code>end</code> are not 1390 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1391 * refers to the first result in the set. Setting both <code>start</code> 1392 * and <code>end</code> to {@link 1393 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1394 * result set. 1395 * </p> 1396 * 1397 * @param groupId the primary key of the group 1398 * @param userId the primary key of the user who created the file 1399 (optionally <code>0</code>) 1400 * @param start the lower bound of the range of results 1401 * @param end the upper bound of the range of results (not inclusive) 1402 * @return the range of matching file entries ordered by date modified 1403 * @throws PortalException if the group could not be found 1404 */ 1405 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1406 long groupId, long userId, int start, int end) 1407 throws com.liferay.portal.kernel.exception.PortalException { 1408 return getService().getGroupFileEntries(groupId, userId, start, end); 1409 } 1410 1411 /** 1412 * Returns an ordered range of all the file entries in the group that are 1413 * stored within the Liferay repository. This method is primarily used to 1414 * search for recently modified file entries. It can be limited to the file 1415 * entries modified by a given user. 1416 * 1417 * <p> 1418 * Useful when paginating results. Returns a maximum of <code>end - 1419 * start</code> instances. <code>start</code> and <code>end</code> are not 1420 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1421 * refers to the first result in the set. Setting both <code>start</code> 1422 * and <code>end</code> to {@link 1423 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1424 * result set. 1425 * </p> 1426 * 1427 * @param groupId the primary key of the group 1428 * @param userId the primary key of the user who created the file 1429 (optionally <code>0</code>) 1430 * @param start the lower bound of the range of results 1431 * @param end the upper bound of the range of results (not inclusive) 1432 * @param obc the comparator to order the file entries (optionally 1433 <code>null</code>) 1434 * @return the range of matching file entries ordered by comparator 1435 <code>obc</code> 1436 * @throws PortalException if the group could not be found 1437 */ 1438 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1439 long groupId, long userId, int start, int end, 1440 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 1441 throws com.liferay.portal.kernel.exception.PortalException { 1442 return getService().getGroupFileEntries(groupId, userId, start, end, obc); 1443 } 1444 1445 /** 1446 * Returns the number of file entries in a group starting at the repository 1447 * default parent folder that are stored within the Liferay repository. This 1448 * method is primarily used to search for recently modified file entries. It 1449 * can be limited to the file entries modified by a given user. 1450 * 1451 * @param groupId the primary key of the group 1452 * @param userId the primary key of the user who created the file 1453 (optionally <code>0</code>) 1454 * @return the number of matching file entries 1455 * @throws PortalException if the group could not be found 1456 */ 1457 public static int getGroupFileEntriesCount(long groupId, long userId) 1458 throws com.liferay.portal.kernel.exception.PortalException { 1459 return getService().getGroupFileEntriesCount(groupId, userId); 1460 } 1461 1462 /** 1463 * Returns the number of file entries in a group starting at the root folder 1464 * that are stored within the Liferay repository. This method is primarily 1465 * used to search for recently modified file entries. It can be limited to 1466 * the file entries modified by a given user. 1467 * 1468 * @param groupId the primary key of the group 1469 * @param userId the primary key of the user who created the file 1470 (optionally <code>0</code>) 1471 * @param rootFolderId the primary key of the root folder to begin the 1472 search 1473 * @return the number of matching file entries 1474 * @throws PortalException if the group could not be found 1475 */ 1476 public static int getGroupFileEntriesCount(long groupId, long userId, 1477 long rootFolderId) 1478 throws com.liferay.portal.kernel.exception.PortalException { 1479 return getService() 1480 .getGroupFileEntriesCount(groupId, userId, rootFolderId); 1481 } 1482 1483 public static int getGroupFileEntriesCount(long groupId, long userId, 1484 long rootFolderId, java.lang.String[] mimeTypes, int status) 1485 throws com.liferay.portal.kernel.exception.PortalException { 1486 return getService() 1487 .getGroupFileEntriesCount(groupId, userId, rootFolderId, 1488 mimeTypes, status); 1489 } 1490 1491 /** 1492 * Returns all immediate subfolders of the parent folder that are used for 1493 * mounting third-party repositories. This method is only supported by the 1494 * Liferay repository. 1495 * 1496 * @param repositoryId the primary key of the folder's repository 1497 * @param parentFolderId the primary key of the folder's parent folder 1498 * @return the immediate subfolders of the parent folder that are used for 1499 mounting third-party repositories 1500 * @throws PortalException if the repository or parent folder could not be 1501 found 1502 */ 1503 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders( 1504 long repositoryId, long parentFolderId) 1505 throws com.liferay.portal.kernel.exception.PortalException { 1506 return getService().getMountFolders(repositoryId, parentFolderId); 1507 } 1508 1509 /** 1510 * Returns a range of all the immediate subfolders of the parent folder that 1511 * are used for mounting third-party repositories. This method is only 1512 * supported by the Liferay repository. 1513 * 1514 * <p> 1515 * Useful when paginating results. Returns a maximum of <code>end - 1516 * start</code> instances. <code>start</code> and <code>end</code> are not 1517 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1518 * refers to the first result in the set. Setting both <code>start</code> 1519 * and <code>end</code> to {@link 1520 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1521 * result set. 1522 * </p> 1523 * 1524 * @param repositoryId the primary key of the repository 1525 * @param parentFolderId the primary key of the parent folder 1526 * @param start the lower bound of the range of results 1527 * @param end the upper bound of the range of results (not inclusive) 1528 * @return the range of immediate subfolders of the parent folder that are 1529 used for mounting third-party repositories 1530 * @throws PortalException if the repository or parent folder could not be 1531 found 1532 */ 1533 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders( 1534 long repositoryId, long parentFolderId, int start, int end) 1535 throws com.liferay.portal.kernel.exception.PortalException { 1536 return getService() 1537 .getMountFolders(repositoryId, parentFolderId, start, end); 1538 } 1539 1540 /** 1541 * Returns an ordered range of all the immediate subfolders of the parent 1542 * folder that are used for mounting third-party repositories. This method 1543 * is only supported by the Liferay repository. 1544 * 1545 * <p> 1546 * Useful when paginating results. Returns a maximum of <code>end - 1547 * start</code> instances. <code>start</code> and <code>end</code> are not 1548 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1549 * refers to the first result in the set. Setting both <code>start</code> 1550 * and <code>end</code> to {@link 1551 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1552 * result set. 1553 * </p> 1554 * 1555 * @param repositoryId the primary key of the folder's repository 1556 * @param parentFolderId the primary key of the folder's parent folder 1557 * @param start the lower bound of the range of results 1558 * @param end the upper bound of the range of results (not inclusive) 1559 * @param obc the comparator to order the folders (optionally 1560 <code>null</code>) 1561 * @return the range of immediate subfolders of the parent folder that are 1562 used for mounting third-party repositories ordered by comparator 1563 <code>obc</code> 1564 * @throws PortalException if the repository or parent folder could not be 1565 found 1566 */ 1567 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders( 1568 long repositoryId, long parentFolderId, int start, int end, 1569 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1570 throws com.liferay.portal.kernel.exception.PortalException { 1571 return getService() 1572 .getMountFolders(repositoryId, parentFolderId, start, end, 1573 obc); 1574 } 1575 1576 /** 1577 * Returns the number of immediate subfolders of the parent folder that are 1578 * used for mounting third-party repositories. This method is only supported 1579 * by the Liferay repository. 1580 * 1581 * @param repositoryId the primary key of the repository 1582 * @param parentFolderId the primary key of the parent folder 1583 * @return the number of folders of the parent folder that are used for 1584 mounting third-party repositories 1585 * @throws PortalException if the repository or parent folder could not be 1586 found 1587 */ 1588 public static int getMountFoldersCount(long repositoryId, 1589 long parentFolderId) 1590 throws com.liferay.portal.kernel.exception.PortalException { 1591 return getService().getMountFoldersCount(repositoryId, parentFolderId); 1592 } 1593 1594 /** 1595 * Returns all the descendant folders of the folder with the primary key. 1596 * 1597 * @param repositoryId the primary key of the repository 1598 * @param folderId the primary key of the folder 1599 * @return the descendant folders of the folder with the primary key 1600 * @throws PortalException if the repository or parent folder could not be 1601 found 1602 */ 1603 public static java.util.List<java.lang.Long> getSubfolderIds( 1604 long repositoryId, long folderId) 1605 throws com.liferay.portal.kernel.exception.PortalException { 1606 return getService().getSubfolderIds(repositoryId, folderId); 1607 } 1608 1609 /** 1610 * Returns descendant folders of the folder with the primary key, optionally 1611 * limiting to one level deep. 1612 * 1613 * @param repositoryId the primary key of the repository 1614 * @param folderId the primary key of the folder 1615 * @param recurse whether to recurse through each subfolder 1616 * @return the descendant folders of the folder with the primary key 1617 * @throws PortalException if the repository or parent folder could not be 1618 found 1619 */ 1620 public static java.util.List<java.lang.Long> getSubfolderIds( 1621 long repositoryId, long folderId, boolean recurse) 1622 throws com.liferay.portal.kernel.exception.PortalException { 1623 return getService().getSubfolderIds(repositoryId, folderId, recurse); 1624 } 1625 1626 public static void getSubfolderIds(long repositoryId, 1627 java.util.List<java.lang.Long> folderIds, long folderId) 1628 throws com.liferay.portal.kernel.exception.PortalException { 1629 getService().getSubfolderIds(repositoryId, folderIds, folderId); 1630 } 1631 1632 /** 1633 * Returns all the temporary file entry names. 1634 * 1635 * @param groupId the primary key of the group 1636 * @param folderId the primary key of the folder where the file entry will 1637 eventually reside 1638 * @param folderName the temporary folder's name 1639 * @return the temporary file entry names 1640 * @throws PortalException if the folder was invalid 1641 * @see #addTempFileEntry(long, long, String, String, File, String) 1642 * @see com.liferay.portal.kernel.util.TempFileEntryUtil 1643 */ 1644 public static java.lang.String[] getTempFileNames(long groupId, 1645 long folderId, java.lang.String folderName) 1646 throws com.liferay.portal.kernel.exception.PortalException { 1647 return getService().getTempFileNames(groupId, folderId, folderName); 1648 } 1649 1650 /** 1651 * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long, 1652 ServiceContext)} 1653 */ 1654 @Deprecated 1655 public static com.liferay.portal.model.Lock lockFileEntry(long fileEntryId) 1656 throws com.liferay.portal.kernel.exception.PortalException { 1657 return getService().lockFileEntry(fileEntryId); 1658 } 1659 1660 /** 1661 * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long, 1662 String, long, ServiceContext)} 1663 */ 1664 @Deprecated 1665 public static com.liferay.portal.model.Lock lockFileEntry( 1666 long fileEntryId, java.lang.String owner, long expirationTime) 1667 throws com.liferay.portal.kernel.exception.PortalException { 1668 return getService().lockFileEntry(fileEntryId, owner, expirationTime); 1669 } 1670 1671 /** 1672 * Locks the folder. This method is primarily used by WebDAV. 1673 * 1674 * @param repositoryId the primary key of the repository 1675 * @param folderId the primary key of the folder 1676 * @return the lock object 1677 * @throws PortalException if the repository or folder could not be found 1678 */ 1679 public static com.liferay.portal.model.Lock lockFolder(long repositoryId, 1680 long folderId) 1681 throws com.liferay.portal.kernel.exception.PortalException { 1682 return getService().lockFolder(repositoryId, folderId); 1683 } 1684 1685 /** 1686 * Locks the folder. This method is primarily used by WebDAV. 1687 * 1688 * @param repositoryId the primary key of the repository 1689 * @param folderId the primary key of the folder 1690 * @param owner the owner string for the checkout (optionally 1691 <code>null</code>) 1692 * @param inheritable whether the lock must propagate to descendants 1693 * @param expirationTime the time in milliseconds before the lock expires. 1694 If the value is <code>0</code>, the default expiration time will 1695 be used from <code>portal.properties>. 1696 * @return the lock object 1697 * @throws PortalException if the repository or folder could not be found 1698 */ 1699 public static com.liferay.portal.model.Lock lockFolder(long repositoryId, 1700 long folderId, java.lang.String owner, boolean inheritable, 1701 long expirationTime) 1702 throws com.liferay.portal.kernel.exception.PortalException { 1703 return getService() 1704 .lockFolder(repositoryId, folderId, owner, inheritable, 1705 expirationTime); 1706 } 1707 1708 /** 1709 * Moves the file entry to the new folder. 1710 * 1711 * @param fileEntryId the primary key of the file entry 1712 * @param newFolderId the primary key of the new folder 1713 * @param serviceContext the service context to be applied 1714 * @return the file entry 1715 * @throws PortalException if the file entry or the new folder could not be 1716 found 1717 */ 1718 public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntry( 1719 long fileEntryId, long newFolderId, 1720 com.liferay.portal.service.ServiceContext serviceContext) 1721 throws com.liferay.portal.kernel.exception.PortalException { 1722 return getService() 1723 .moveFileEntry(fileEntryId, newFolderId, serviceContext); 1724 } 1725 1726 /** 1727 * Moves the file entry from a trashed folder to the new folder. 1728 * 1729 * @param fileEntryId the primary key of the file entry 1730 * @param newFolderId the primary key of the new folder 1731 * @param serviceContext the service context to be applied 1732 * @return the file entry 1733 * @throws PortalException if the file entry or the new folder could not be 1734 found 1735 */ 1736 public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryFromTrash( 1737 long fileEntryId, long newFolderId, 1738 com.liferay.portal.service.ServiceContext serviceContext) 1739 throws com.liferay.portal.kernel.exception.PortalException { 1740 return getService() 1741 .moveFileEntryFromTrash(fileEntryId, newFolderId, 1742 serviceContext); 1743 } 1744 1745 /** 1746 * Moves the file entry with the primary key to the trash portlet. 1747 * 1748 * @param fileEntryId the primary key of the file entry 1749 * @return the file entry 1750 * @throws PortalException if the file entry could not be found 1751 */ 1752 public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryToTrash( 1753 long fileEntryId) 1754 throws com.liferay.portal.kernel.exception.PortalException { 1755 return getService().moveFileEntryToTrash(fileEntryId); 1756 } 1757 1758 /** 1759 * Moves the file shortcut from a trashed folder to the new folder. 1760 * 1761 * @param fileShortcutId the primary key of the file shortcut 1762 * @param newFolderId the primary key of the new folder 1763 * @param serviceContext the service context to be applied 1764 * @return the file shortcut 1765 * @throws PortalException if the file entry or the new folder could not be 1766 found 1767 */ 1768 public static com.liferay.portlet.documentlibrary.model.DLFileShortcut moveFileShortcutFromTrash( 1769 long fileShortcutId, long newFolderId, 1770 com.liferay.portal.service.ServiceContext serviceContext) 1771 throws com.liferay.portal.kernel.exception.PortalException { 1772 return getService() 1773 .moveFileShortcutFromTrash(fileShortcutId, newFolderId, 1774 serviceContext); 1775 } 1776 1777 /** 1778 * Moves the file shortcut with the primary key to the trash portlet. 1779 * 1780 * @param fileShortcutId the primary key of the file shortcut 1781 * @return the file shortcut 1782 * @throws PortalException if the file shortcut could not be found 1783 */ 1784 public static com.liferay.portlet.documentlibrary.model.DLFileShortcut moveFileShortcutToTrash( 1785 long fileShortcutId) 1786 throws com.liferay.portal.kernel.exception.PortalException { 1787 return getService().moveFileShortcutToTrash(fileShortcutId); 1788 } 1789 1790 /** 1791 * Moves the folder to the new parent folder with the primary key. 1792 * 1793 * @param folderId the primary key of the folder 1794 * @param parentFolderId the primary key of the new parent folder 1795 * @param serviceContext the service context to be applied 1796 * @return the file entry 1797 * @throws PortalException if the folder could not be found 1798 */ 1799 public static com.liferay.portal.kernel.repository.model.Folder moveFolder( 1800 long folderId, long parentFolderId, 1801 com.liferay.portal.service.ServiceContext serviceContext) 1802 throws com.liferay.portal.kernel.exception.PortalException { 1803 return getService().moveFolder(folderId, parentFolderId, serviceContext); 1804 } 1805 1806 /** 1807 * Moves the folder with the primary key from the trash portlet to the new 1808 * parent folder with the primary key. 1809 * 1810 * @param folderId the primary key of the folder 1811 * @param parentFolderId the primary key of the new parent folder 1812 * @param serviceContext the service context to be applied 1813 * @return the file entry 1814 * @throws PortalException if the folder could not be found 1815 */ 1816 public static com.liferay.portal.kernel.repository.model.Folder moveFolderFromTrash( 1817 long folderId, long parentFolderId, 1818 com.liferay.portal.service.ServiceContext serviceContext) 1819 throws com.liferay.portal.kernel.exception.PortalException { 1820 return getService() 1821 .moveFolderFromTrash(folderId, parentFolderId, serviceContext); 1822 } 1823 1824 /** 1825 * Moves the folder with the primary key to the trash portlet. 1826 * 1827 * @param folderId the primary key of the folder 1828 * @return the file entry 1829 * @throws PortalException if the folder could not be found 1830 */ 1831 public static com.liferay.portal.kernel.repository.model.Folder moveFolderToTrash( 1832 long folderId) 1833 throws com.liferay.portal.kernel.exception.PortalException { 1834 return getService().moveFolderToTrash(folderId); 1835 } 1836 1837 /** 1838 * Refreshes the lock for the file entry. This method is primarily used by 1839 * WebDAV. 1840 * 1841 * @param lockUuid the lock's UUID 1842 * @param companyId the primary key of the file entry's company 1843 * @param expirationTime the time in milliseconds before the lock expires. 1844 If the value is <code>0</code>, the default expiration time will 1845 be used from <code>portal.properties>. 1846 * @return the lock object 1847 * @throws PortalException if the file entry or lock could not be found 1848 */ 1849 public static com.liferay.portal.model.Lock refreshFileEntryLock( 1850 java.lang.String lockUuid, long companyId, long expirationTime) 1851 throws com.liferay.portal.kernel.exception.PortalException { 1852 return getService() 1853 .refreshFileEntryLock(lockUuid, companyId, expirationTime); 1854 } 1855 1856 /** 1857 * Refreshes the lock for the folder. This method is primarily used by 1858 * WebDAV. 1859 * 1860 * @param lockUuid the lock's UUID 1861 * @param companyId the primary key of the file entry's company 1862 * @param expirationTime the time in milliseconds before the lock expires. 1863 If the value is <code>0</code>, the default expiration time will 1864 be used from <code>portal.properties>. 1865 * @return the lock object 1866 * @throws PortalException if the folder or lock could not be found 1867 */ 1868 public static com.liferay.portal.model.Lock refreshFolderLock( 1869 java.lang.String lockUuid, long companyId, long expirationTime) 1870 throws com.liferay.portal.kernel.exception.PortalException { 1871 return getService() 1872 .refreshFolderLock(lockUuid, companyId, expirationTime); 1873 } 1874 1875 /** 1876 * Restores the file entry with the primary key from the trash portlet. 1877 * 1878 * @param fileEntryId the primary key of the file entry 1879 * @throws PortalException if the file entry could not be found 1880 */ 1881 public static void restoreFileEntryFromTrash(long fileEntryId) 1882 throws com.liferay.portal.kernel.exception.PortalException { 1883 getService().restoreFileEntryFromTrash(fileEntryId); 1884 } 1885 1886 /** 1887 * Restores the file shortcut with the primary key from the trash portlet. 1888 * 1889 * @param fileShortcutId the primary key of the file shortcut 1890 * @throws PortalException if the file shortcut could not be found 1891 */ 1892 public static void restoreFileShortcutFromTrash(long fileShortcutId) 1893 throws com.liferay.portal.kernel.exception.PortalException { 1894 getService().restoreFileShortcutFromTrash(fileShortcutId); 1895 } 1896 1897 /** 1898 * Restores the folder with the primary key from the trash portlet. 1899 * 1900 * @param folderId the primary key of the folder 1901 * @throws PortalException if the folder could not be found 1902 */ 1903 public static void restoreFolderFromTrash(long folderId) 1904 throws com.liferay.portal.kernel.exception.PortalException { 1905 getService().restoreFolderFromTrash(folderId); 1906 } 1907 1908 /** 1909 * Reverts the file entry to a previous version. A new version will be 1910 * created based on the previous version and metadata. 1911 * 1912 * @param fileEntryId the primary key of the file entry 1913 * @param version the version to revert back to 1914 * @param serviceContext the service context to be applied 1915 * @throws PortalException if the file entry or version could not be found 1916 */ 1917 public static void revertFileEntry(long fileEntryId, 1918 java.lang.String version, 1919 com.liferay.portal.service.ServiceContext serviceContext) 1920 throws com.liferay.portal.kernel.exception.PortalException { 1921 getService().revertFileEntry(fileEntryId, version, serviceContext); 1922 } 1923 1924 public static com.liferay.portal.kernel.search.Hits search( 1925 long repositoryId, long creatorUserId, long folderId, 1926 java.lang.String[] mimeTypes, int status, int start, int end) 1927 throws com.liferay.portal.kernel.exception.PortalException { 1928 return getService() 1929 .search(repositoryId, creatorUserId, folderId, mimeTypes, 1930 status, start, end); 1931 } 1932 1933 public static com.liferay.portal.kernel.search.Hits search( 1934 long repositoryId, long creatorUserId, int status, int start, int end) 1935 throws com.liferay.portal.kernel.exception.PortalException { 1936 return getService() 1937 .search(repositoryId, creatorUserId, status, start, end); 1938 } 1939 1940 public static com.liferay.portal.kernel.search.Hits search( 1941 long repositoryId, 1942 com.liferay.portal.kernel.search.SearchContext searchContext) 1943 throws com.liferay.portal.kernel.search.SearchException { 1944 return getService().search(repositoryId, searchContext); 1945 } 1946 1947 public static com.liferay.portal.kernel.search.Hits search( 1948 long repositoryId, 1949 com.liferay.portal.kernel.search.SearchContext searchContext, 1950 com.liferay.portal.kernel.search.Query query) 1951 throws com.liferay.portal.kernel.search.SearchException { 1952 return getService().search(repositoryId, searchContext, query); 1953 } 1954 1955 /** 1956 * Sets the Spring bean ID for this bean. 1957 * 1958 * @param beanIdentifier the Spring bean ID for this bean 1959 */ 1960 public static void setBeanIdentifier(java.lang.String beanIdentifier) { 1961 getService().setBeanIdentifier(beanIdentifier); 1962 } 1963 1964 /** 1965 * Subscribe the user to changes in documents of the file entry type. This 1966 * method is only supported by the Liferay repository. 1967 * 1968 * @param groupId the primary key of the file entry type's group 1969 * @param fileEntryTypeId the primary key of the file entry type 1970 * @throws PortalException if the user or group could not be found, or if 1971 subscribing was not permissible 1972 */ 1973 public static void subscribeFileEntryType(long groupId, long fileEntryTypeId) 1974 throws com.liferay.portal.kernel.exception.PortalException { 1975 getService().subscribeFileEntryType(groupId, fileEntryTypeId); 1976 } 1977 1978 /** 1979 * Subscribe the user to document changes in the folder. This method is only 1980 * supported by the Liferay repository. 1981 * 1982 * @param groupId the primary key of the folder's group 1983 * @param folderId the primary key of the folder 1984 * @throws PortalException if the user or group could not be found, or if 1985 subscribing was not permissible 1986 */ 1987 public static void subscribeFolder(long groupId, long folderId) 1988 throws com.liferay.portal.kernel.exception.PortalException { 1989 getService().subscribeFolder(groupId, folderId); 1990 } 1991 1992 /** 1993 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 1994 boolean, String, ServiceContext)}. 1995 */ 1996 @Deprecated 1997 public static void unlockFileEntry(long fileEntryId) 1998 throws com.liferay.portal.kernel.exception.PortalException { 1999 getService().unlockFileEntry(fileEntryId); 2000 } 2001 2002 /** 2003 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 2004 String)}. 2005 */ 2006 @Deprecated 2007 public static void unlockFileEntry(long fileEntryId, 2008 java.lang.String lockUuid) 2009 throws com.liferay.portal.kernel.exception.PortalException { 2010 getService().unlockFileEntry(fileEntryId, lockUuid); 2011 } 2012 2013 /** 2014 * Unlocks the folder. This method is primarily used by WebDAV. 2015 * 2016 * @param repositoryId the primary key of the repository 2017 * @param folderId the primary key of the folder 2018 * @param lockUuid the lock's UUID 2019 * @throws PortalException if the repository or folder could not be found 2020 */ 2021 public static void unlockFolder(long repositoryId, long folderId, 2022 java.lang.String lockUuid) 2023 throws com.liferay.portal.kernel.exception.PortalException { 2024 getService().unlockFolder(repositoryId, folderId, lockUuid); 2025 } 2026 2027 /** 2028 * Unlocks the folder. This method is primarily used by WebDAV. 2029 * 2030 * @param repositoryId the primary key of the repository 2031 * @param parentFolderId the primary key of the parent folder 2032 * @param name the folder's name 2033 * @param lockUuid the lock's UUID 2034 * @throws PortalException if the repository or folder could not be found 2035 */ 2036 public static void unlockFolder(long repositoryId, long parentFolderId, 2037 java.lang.String name, java.lang.String lockUuid) 2038 throws com.liferay.portal.kernel.exception.PortalException { 2039 getService().unlockFolder(repositoryId, parentFolderId, name, lockUuid); 2040 } 2041 2042 /** 2043 * Unsubscribe the user from changes in documents of the file entry type. 2044 * This method is only supported by the Liferay repository. 2045 * 2046 * @param groupId the primary key of the file entry type's group 2047 * @param fileEntryTypeId the primary key of the file entry type 2048 * @throws PortalException if the user or group could not be found, or if 2049 unsubscribing was not permissible 2050 */ 2051 public static void unsubscribeFileEntryType(long groupId, 2052 long fileEntryTypeId) 2053 throws com.liferay.portal.kernel.exception.PortalException { 2054 getService().unsubscribeFileEntryType(groupId, fileEntryTypeId); 2055 } 2056 2057 /** 2058 * Unsubscribe the user from document changes in the folder. This method is 2059 * only supported by the Liferay repository. 2060 * 2061 * @param groupId the primary key of the folder's group 2062 * @param folderId the primary key of the folder 2063 * @throws PortalException if the user or group could not be found, or if 2064 unsubscribing was not permissible 2065 */ 2066 public static void unsubscribeFolder(long groupId, long folderId) 2067 throws com.liferay.portal.kernel.exception.PortalException { 2068 getService().unsubscribeFolder(groupId, folderId); 2069 } 2070 2071 /** 2072 * Updates a file entry and associated metadata based on a byte array 2073 * object. If the file data is <code>null</code>, then only the associated 2074 * metadata (i.e., <code>title</code>, <code>description</code>, and 2075 * parameters in the <code>serviceContext</code>) will be updated. 2076 * 2077 * <p> 2078 * This method takes two file names, the <code>sourceFileName</code> and the 2079 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2080 * name of the actual file being uploaded. The <code>title</code> 2081 * corresponds to a name the client wishes to assign this file after it has 2082 * been uploaded to the portal. 2083 * </p> 2084 * 2085 * @param fileEntryId the primary key of the file entry 2086 * @param sourceFileName the original file's name (optionally 2087 <code>null</code>) 2088 * @param mimeType the file's MIME type (optionally <code>null</code>) 2089 * @param title the new name to be assigned to the file (optionally <code> 2090 <code>null</code></code>) 2091 * @param description the file's new description 2092 * @param changeLog the file's version change log (optionally 2093 <code>null</code>) 2094 * @param majorVersion whether the new file version is a major version 2095 * @param bytes the file's data (optionally <code>null</code>) 2096 * @param serviceContext the service context to be applied. Can set the 2097 asset category IDs, asset tag names, and expando bridge 2098 attributes for the file entry. In a Liferay repository, it may 2099 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2100 type </li> <li> fieldsMap - mapping for fields associated with a 2101 custom file entry type </li> </ul> 2102 * @return the file entry 2103 * @throws PortalException if the file entry could not be found 2104 */ 2105 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry( 2106 long fileEntryId, java.lang.String sourceFileName, 2107 java.lang.String mimeType, java.lang.String title, 2108 java.lang.String description, java.lang.String changeLog, 2109 boolean majorVersion, byte[] bytes, 2110 com.liferay.portal.service.ServiceContext serviceContext) 2111 throws com.liferay.portal.kernel.exception.PortalException { 2112 return getService() 2113 .updateFileEntry(fileEntryId, sourceFileName, mimeType, 2114 title, description, changeLog, majorVersion, bytes, serviceContext); 2115 } 2116 2117 /** 2118 * Updates a file entry and associated metadata based on a {@link 2119 * java.io.File} object. If the file data is <code>null</code>, then only 2120 * the associated metadata (i.e., <code>title</code>, 2121 * <code>description</code>, and parameters in the 2122 * <code>serviceContext</code>) will be updated. 2123 * 2124 * <p> 2125 * This method takes two file names, the <code>sourceFileName</code> and the 2126 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2127 * name of the actual file being uploaded. The <code>title</code> 2128 * corresponds to a name the client wishes to assign this file after it has 2129 * been uploaded to the portal. 2130 * </p> 2131 * 2132 * @param fileEntryId the primary key of the file entry 2133 * @param sourceFileName the original file's name (optionally 2134 <code>null</code>) 2135 * @param mimeType the file's MIME type (optionally <code>null</code>) 2136 * @param title the new name to be assigned to the file (optionally <code> 2137 <code>null</code></code>) 2138 * @param description the file's new description 2139 * @param changeLog the file's version change log (optionally 2140 <code>null</code>) 2141 * @param majorVersion whether the new file version is a major version 2142 * @param file the file's data (optionally <code>null</code>) 2143 * @param serviceContext the service context to be applied. Can set the 2144 asset category IDs, asset tag names, and expando bridge 2145 attributes for the file entry. In a Liferay repository, it may 2146 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2147 type </li> <li> fieldsMap - mapping for fields associated with a 2148 custom file entry type </li> </ul> 2149 * @return the file entry 2150 * @throws PortalException if the file entry could not be found 2151 */ 2152 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry( 2153 long fileEntryId, java.lang.String sourceFileName, 2154 java.lang.String mimeType, java.lang.String title, 2155 java.lang.String description, java.lang.String changeLog, 2156 boolean majorVersion, java.io.File file, 2157 com.liferay.portal.service.ServiceContext serviceContext) 2158 throws com.liferay.portal.kernel.exception.PortalException { 2159 return getService() 2160 .updateFileEntry(fileEntryId, sourceFileName, mimeType, 2161 title, description, changeLog, majorVersion, file, serviceContext); 2162 } 2163 2164 /** 2165 * Updates a file entry and associated metadata based on an {@link 2166 * InputStream} object. If the file data is <code>null</code>, then only the 2167 * associated metadata (i.e., <code>title</code>, <code>description</code>, 2168 * and parameters in the <code>serviceContext</code>) will be updated. 2169 * 2170 * <p> 2171 * This method takes two file names, the <code>sourceFileName</code> and the 2172 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2173 * name of the actual file being uploaded. The <code>title</code> 2174 * corresponds to a name the client wishes to assign this file after it has 2175 * been uploaded to the portal. 2176 * </p> 2177 * 2178 * @param fileEntryId the primary key of the file entry 2179 * @param sourceFileName the original file's name (optionally 2180 <code>null</code>) 2181 * @param mimeType the file's MIME type (optionally <code>null</code>) 2182 * @param title the new name to be assigned to the file (optionally <code> 2183 <code>null</code></code>) 2184 * @param description the file's new description 2185 * @param changeLog the file's version change log (optionally 2186 <code>null</code>) 2187 * @param majorVersion whether the new file version is a major version 2188 * @param is the file's data (optionally <code>null</code>) 2189 * @param size the file's size (optionally <code>0</code>) 2190 * @param serviceContext the service context to be applied. Can set the 2191 asset category IDs, asset tag names, and expando bridge 2192 attributes for the file entry. In a Liferay repository, it may 2193 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2194 type </li> <li> fieldsMap - mapping for fields associated with a 2195 custom file entry type </li> </ul> 2196 * @return the file entry 2197 * @throws PortalException if the file entry could not be found 2198 */ 2199 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry( 2200 long fileEntryId, java.lang.String sourceFileName, 2201 java.lang.String mimeType, java.lang.String title, 2202 java.lang.String description, java.lang.String changeLog, 2203 boolean majorVersion, java.io.InputStream is, long size, 2204 com.liferay.portal.service.ServiceContext serviceContext) 2205 throws com.liferay.portal.kernel.exception.PortalException { 2206 return getService() 2207 .updateFileEntry(fileEntryId, sourceFileName, mimeType, 2208 title, description, changeLog, majorVersion, is, size, 2209 serviceContext); 2210 } 2211 2212 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn( 2213 long fileEntryId, java.lang.String sourceFileName, 2214 java.lang.String mimeType, java.lang.String title, 2215 java.lang.String description, java.lang.String changeLog, 2216 boolean majorVersion, java.io.File file, 2217 com.liferay.portal.service.ServiceContext serviceContext) 2218 throws com.liferay.portal.kernel.exception.PortalException { 2219 return getService() 2220 .updateFileEntryAndCheckIn(fileEntryId, sourceFileName, 2221 mimeType, title, description, changeLog, majorVersion, file, 2222 serviceContext); 2223 } 2224 2225 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn( 2226 long fileEntryId, java.lang.String sourceFileName, 2227 java.lang.String mimeType, java.lang.String title, 2228 java.lang.String description, java.lang.String changeLog, 2229 boolean majorVersion, java.io.InputStream is, long size, 2230 com.liferay.portal.service.ServiceContext serviceContext) 2231 throws com.liferay.portal.kernel.exception.PortalException { 2232 return getService() 2233 .updateFileEntryAndCheckIn(fileEntryId, sourceFileName, 2234 mimeType, title, description, changeLog, majorVersion, is, size, 2235 serviceContext); 2236 } 2237 2238 /** 2239 * Updates a file shortcut to the existing file entry. This method is only 2240 * supported by the Liferay repository. 2241 * 2242 * @param fileShortcutId the primary key of the file shortcut 2243 * @param folderId the primary key of the file shortcut's parent folder 2244 * @param toFileEntryId the primary key of the file shortcut's file entry 2245 * @param serviceContext the service context to be applied. Can set the 2246 asset category IDs, asset tag names, and expando bridge 2247 attributes for the file entry. 2248 * @return the file shortcut 2249 * @throws PortalException if the file shortcut, folder, or file entry could 2250 not be found 2251 */ 2252 public static com.liferay.portlet.documentlibrary.model.DLFileShortcut updateFileShortcut( 2253 long fileShortcutId, long folderId, long toFileEntryId, 2254 com.liferay.portal.service.ServiceContext serviceContext) 2255 throws com.liferay.portal.kernel.exception.PortalException { 2256 return getService() 2257 .updateFileShortcut(fileShortcutId, folderId, toFileEntryId, 2258 serviceContext); 2259 } 2260 2261 /** 2262 * Updates the folder. 2263 * 2264 * @param folderId the primary key of the folder 2265 * @param name the folder's new name 2266 * @param description the folder's new description 2267 * @param serviceContext the service context to be applied. In a Liferay 2268 repository, it may include: <ul> <li> defaultFileEntryTypeId - 2269 the file entry type to default all Liferay file entries to </li> 2270 <li> dlFileEntryTypesSearchContainerPrimaryKeys - a 2271 comma-delimited list of file entry type primary keys allowed in 2272 the given folder and all descendants </li> <li> restrictionType - 2273 specifying restriction type of file entry types allowed </li> 2274 <li> workflowDefinitionXYZ - the workflow definition name 2275 specified per file entry type. The parameter name must be the 2276 string <code>workflowDefinition</code> appended by the 2277 <code>fileEntryTypeId</code> (optionally <code>0</code>).</li> 2278 </ul> 2279 * @return the folder 2280 * @throws PortalException if the current or new parent folder could not be 2281 found or if the new parent folder's information was invalid 2282 */ 2283 public static com.liferay.portal.kernel.repository.model.Folder updateFolder( 2284 long folderId, java.lang.String name, java.lang.String description, 2285 com.liferay.portal.service.ServiceContext serviceContext) 2286 throws com.liferay.portal.kernel.exception.PortalException { 2287 return getService() 2288 .updateFolder(folderId, name, description, serviceContext); 2289 } 2290 2291 /** 2292 * Returns <code>true</code> if the file entry is checked out. This method 2293 * is primarily used by WebDAV. 2294 * 2295 * @param repositoryId the primary key for the repository 2296 * @param fileEntryId the primary key for the file entry 2297 * @param lockUuid the lock's UUID 2298 * @return <code>true</code> if the file entry is checked out; 2299 <code>false</code> otherwise 2300 * @throws PortalException if the file entry could not be found 2301 */ 2302 public static boolean verifyFileEntryCheckOut(long repositoryId, 2303 long fileEntryId, java.lang.String lockUuid) 2304 throws com.liferay.portal.kernel.exception.PortalException { 2305 return getService() 2306 .verifyFileEntryCheckOut(repositoryId, fileEntryId, lockUuid); 2307 } 2308 2309 public static boolean verifyFileEntryLock(long repositoryId, 2310 long fileEntryId, java.lang.String lockUuid) 2311 throws com.liferay.portal.kernel.exception.PortalException { 2312 return getService() 2313 .verifyFileEntryLock(repositoryId, fileEntryId, lockUuid); 2314 } 2315 2316 /** 2317 * Returns <code>true</code> if the inheritable lock exists. This method is 2318 * primarily used by WebDAV. 2319 * 2320 * @param repositoryId the primary key for the repository 2321 * @param folderId the primary key for the folder 2322 * @param lockUuid the lock's UUID 2323 * @return <code>true</code> if the inheritable lock exists; 2324 <code>false</code> otherwise 2325 * @throws PortalException if the folder could not be found 2326 */ 2327 public static boolean verifyInheritableLock(long repositoryId, 2328 long folderId, java.lang.String lockUuid) 2329 throws com.liferay.portal.kernel.exception.PortalException { 2330 return getService() 2331 .verifyInheritableLock(repositoryId, folderId, lockUuid); 2332 } 2333 2334 public static DLAppService getService() { 2335 if (_service == null) { 2336 _service = (DLAppService)PortalBeanLocatorUtil.locate(DLAppService.class.getName()); 2337 2338 ReferenceRegistry.registerReference(DLAppServiceUtil.class, 2339 "_service"); 2340 } 2341 2342 return _service; 2343 } 2344 2345 /** 2346 * @deprecated As of 6.2.0 2347 */ 2348 @Deprecated 2349 public void setService(DLAppService service) { 2350 } 2351 2352 private static DLAppService _service; 2353 }