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 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.portal.kernel.repository.model.FileShortcut 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 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 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 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 name-ordered range of all the file entries with the file entry 604 * type in the 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 name-ordered range of 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 name-ordered 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 QueryUtil#ALL_POS} will return the full 672 * result set. 673 * </p> 674 * 675 * @param repositoryId the primary key of the file entry's repository 676 * @param folderId the primary key of the file entry's folder 677 * @param start the lower bound of the range of results 678 * @param end the upper bound of the range of results (not inclusive) 679 * @return the name-ordered range of file entries in the folder 680 * @throws PortalException if the folder could not be found 681 */ 682 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 683 long repositoryId, long folderId, int start, int end) 684 throws com.liferay.portal.kernel.exception.PortalException { 685 return getService().getFileEntries(repositoryId, folderId, start, end); 686 } 687 688 /** 689 * Returns an ordered range of all the file entries in the folder. 690 * 691 * <p> 692 * Useful when paginating results. Returns a maximum of <code>end - 693 * start</code> instances. <code>start</code> and <code>end</code> are not 694 * primary keys, they are indexes in the result set. Thus, <code>0</code> 695 * refers to the first result in the set. Setting both <code>start</code> 696 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 697 * result set. 698 * </p> 699 * 700 * @param repositoryId the primary key of the file entry's repository 701 * @param folderId the primary key of the file entry's folder 702 * @param start the lower bound of the range of results 703 * @param end the upper bound of the range of results (not inclusive) 704 * @param obc the comparator to order the file entries (optionally 705 <code>null</code>) 706 * @return the range of file entries in the folder ordered by comparator 707 <code>obc</code> 708 * @throws PortalException if the folder could not be found 709 */ 710 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries( 711 long repositoryId, long folderId, int start, int end, 712 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 713 throws com.liferay.portal.kernel.exception.PortalException { 714 return getService() 715 .getFileEntries(repositoryId, folderId, start, end, obc); 716 } 717 718 /** 719 * Returns a range of all the file entries and shortcuts in the folder. 720 * 721 * <p> 722 * Useful when paginating results. Returns a maximum of <code>end - 723 * start</code> instances. <code>start</code> and <code>end</code> are not 724 * primary keys, they are indexes in the result set. Thus, <code>0</code> 725 * refers to the first result in the set. Setting both <code>start</code> 726 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 727 * result set. 728 * </p> 729 * 730 * @param repositoryId the primary key of the repository 731 * @param folderId the primary key of the folder 732 * @param status the workflow status 733 * @param start the lower bound of the range of results 734 * @param end the upper bound of the range of results (not inclusive) 735 * @return the range of file entries and shortcuts in the folder 736 * @throws PortalException if the folder could not be found 737 */ 738 public static java.util.List<java.lang.Object> getFileEntriesAndFileShortcuts( 739 long repositoryId, long folderId, int status, int start, int end) 740 throws com.liferay.portal.kernel.exception.PortalException { 741 return getService() 742 .getFileEntriesAndFileShortcuts(repositoryId, folderId, 743 status, start, end); 744 } 745 746 /** 747 * Returns the number of file entries and shortcuts in the folder. 748 * 749 * @param repositoryId the primary key of the repository 750 * @param folderId the primary key of the folder 751 * @param status the workflow status 752 * @return the number of file entries and shortcuts in the folder 753 * @throws PortalException if the folder ould not be found 754 */ 755 public static int getFileEntriesAndFileShortcutsCount(long repositoryId, 756 long folderId, int status) 757 throws com.liferay.portal.kernel.exception.PortalException { 758 return getService() 759 .getFileEntriesAndFileShortcutsCount(repositoryId, folderId, 760 status); 761 } 762 763 /** 764 * Returns the number of file entries and shortcuts in the folder. 765 * 766 * @param repositoryId the primary key of the repository 767 * @param folderId the primary key of the folder 768 * @param status the workflow status 769 * @param mimeTypes allowed media types 770 * @return the number of file entries and shortcuts in the folder 771 * @throws PortalException if the folder ould not be found 772 */ 773 public static int getFileEntriesAndFileShortcutsCount(long repositoryId, 774 long folderId, int status, java.lang.String[] mimeTypes) 775 throws com.liferay.portal.kernel.exception.PortalException { 776 return getService() 777 .getFileEntriesAndFileShortcutsCount(repositoryId, folderId, 778 status, mimeTypes); 779 } 780 781 /** 782 * Returns the number of file entries in the folder. 783 * 784 * @param repositoryId the primary key of the file entry's repository 785 * @param folderId the primary key of the file entry's folder 786 * @return the number of file entries in the folder 787 * @throws PortalException if the folder could not be found 788 */ 789 public static int getFileEntriesCount(long repositoryId, long folderId) 790 throws com.liferay.portal.kernel.exception.PortalException { 791 return getService().getFileEntriesCount(repositoryId, folderId); 792 } 793 794 /** 795 * Returns the number of file entries with the file entry type in the 796 * folder. 797 * 798 * @param repositoryId the primary key of the file entry's repository 799 * @param folderId the primary key of the file entry's folder 800 * @param fileEntryTypeId the primary key of the file entry type 801 * @return the number of file entries with the file entry type in the folder 802 * @throws PortalException if the folder could not be found 803 */ 804 public static int getFileEntriesCount(long repositoryId, long folderId, 805 long fileEntryTypeId) 806 throws com.liferay.portal.kernel.exception.PortalException { 807 return getService() 808 .getFileEntriesCount(repositoryId, folderId, fileEntryTypeId); 809 } 810 811 public static int getFileEntriesCount(long repositoryId, long folderId, 812 java.lang.String[] mimeTypes) 813 throws com.liferay.portal.kernel.exception.PortalException { 814 return getService() 815 .getFileEntriesCount(repositoryId, folderId, mimeTypes); 816 } 817 818 /** 819 * Returns the file entry with the primary key. 820 * 821 * @param fileEntryId the primary key of the file entry 822 * @return the file entry with the primary key 823 * @throws PortalException if the file entry could not be found 824 */ 825 public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntry( 826 long fileEntryId) 827 throws com.liferay.portal.kernel.exception.PortalException { 828 return getService().getFileEntry(fileEntryId); 829 } 830 831 /** 832 * Returns the file entry with the title in the folder. 833 * 834 * @param groupId the primary key of the file entry's group 835 * @param folderId the primary key of the file entry's folder 836 * @param title the file entry's title 837 * @return the file entry with the title in the folder 838 * @throws PortalException if the file entry could not be found 839 */ 840 public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntry( 841 long groupId, long folderId, java.lang.String title) 842 throws com.liferay.portal.kernel.exception.PortalException { 843 return getService().getFileEntry(groupId, folderId, title); 844 } 845 846 /** 847 * Returns the file entry with the UUID and group. 848 * 849 * @param uuid the file entry's UUID 850 * @param groupId the primary key of the file entry's group 851 * @return the file entry with the UUID and group 852 * @throws PortalException if the file entry could not be found 853 */ 854 public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntryByUuidAndGroupId( 855 java.lang.String uuid, long groupId) 856 throws com.liferay.portal.kernel.exception.PortalException { 857 return getService().getFileEntryByUuidAndGroupId(uuid, groupId); 858 } 859 860 /** 861 * Returns the file shortcut with the primary key. This method is only 862 * supported by the Liferay repository. 863 * 864 * @param fileShortcutId the primary key of the file shortcut 865 * @return the file shortcut with the primary key 866 * @throws PortalException if the file shortcut could not be found 867 */ 868 public static com.liferay.portal.kernel.repository.model.FileShortcut getFileShortcut( 869 long fileShortcutId) 870 throws com.liferay.portal.kernel.exception.PortalException { 871 return getService().getFileShortcut(fileShortcutId); 872 } 873 874 /** 875 * Returns the file version with the primary key. 876 * 877 * @param fileVersionId the primary key of the file version 878 * @return the file version with the primary key 879 * @throws PortalException if the file version could not be found 880 */ 881 public static com.liferay.portal.kernel.repository.model.FileVersion getFileVersion( 882 long fileVersionId) 883 throws com.liferay.portal.kernel.exception.PortalException { 884 return getService().getFileVersion(fileVersionId); 885 } 886 887 /** 888 * Returns the folder with the primary key. 889 * 890 * @param folderId the primary key of the folder 891 * @return the folder with the primary key 892 * @throws PortalException if the folder could not be found 893 */ 894 public static com.liferay.portal.kernel.repository.model.Folder getFolder( 895 long folderId) 896 throws com.liferay.portal.kernel.exception.PortalException { 897 return getService().getFolder(folderId); 898 } 899 900 /** 901 * Returns the folder with the name in the parent folder. 902 * 903 * @param repositoryId the primary key of the folder's repository 904 * @param parentFolderId the primary key of the folder's parent folder 905 * @param name the folder's name 906 * @return the folder with the name in the parent folder 907 * @throws PortalException if the folder could not be found 908 */ 909 public static com.liferay.portal.kernel.repository.model.Folder getFolder( 910 long repositoryId, long parentFolderId, java.lang.String name) 911 throws com.liferay.portal.kernel.exception.PortalException { 912 return getService().getFolder(repositoryId, parentFolderId, name); 913 } 914 915 /** 916 * Returns all immediate subfolders of the parent folder. 917 * 918 * @param repositoryId the primary key of the folder's repository 919 * @param parentFolderId the primary key of the folder's parent folder 920 * @return the immediate subfolders of the parent folder 921 * @throws PortalException if the parent folder could not be found 922 */ 923 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 924 long repositoryId, long parentFolderId) 925 throws com.liferay.portal.kernel.exception.PortalException { 926 return getService().getFolders(repositoryId, parentFolderId); 927 } 928 929 /** 930 * Returns all immediate subfolders of the parent folder, optionally 931 * including mount folders for third-party repositories. 932 * 933 * @param repositoryId the primary key of the folder's repository 934 * @param parentFolderId the primary key of the folder's parent folder 935 * @param includeMountFolders whether to include mount folders for 936 third-party repositories 937 * @return the immediate subfolders of the parent folder 938 * @throws PortalException if the parent folder could not be found 939 */ 940 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 941 long repositoryId, long parentFolderId, boolean includeMountFolders) 942 throws com.liferay.portal.kernel.exception.PortalException { 943 return getService() 944 .getFolders(repositoryId, parentFolderId, includeMountFolders); 945 } 946 947 /** 948 * Returns a name-ordered range of all the immediate subfolders of the 949 * parent folder, optionally including mount folders for third-party 950 * repositories. 951 * 952 * <p> 953 * Useful when paginating results. Returns a maximum of <code>end - 954 * start</code> instances. <code>start</code> and <code>end</code> are not 955 * primary keys, they are indexes in the result set. Thus, <code>0</code> 956 * refers to the first result in the set. Setting both <code>start</code> 957 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 958 * result set. 959 * </p> 960 * 961 * @param repositoryId the primary key of the folder's repository 962 * @param parentFolderId the primary key of the folder's parent folder 963 * @param includeMountFolders whether to include mount folders for 964 third-party repositories 965 * @param start the lower bound of the range of results 966 * @param end the upper bound of the range of results (not inclusive) 967 * @return the name-ordered range of immediate subfolders of the parent 968 folder 969 * @throws PortalException if the parent folder could not be found 970 */ 971 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 972 long repositoryId, long parentFolderId, boolean includeMountFolders, 973 int start, int end) 974 throws com.liferay.portal.kernel.exception.PortalException { 975 return getService() 976 .getFolders(repositoryId, parentFolderId, 977 includeMountFolders, start, end); 978 } 979 980 /** 981 * Returns an ordered range of all the immediate subfolders of the parent 982 * folder. 983 * 984 * <p> 985 * Useful when paginating results. Returns a maximum of <code>end - 986 * start</code> instances. <code>start</code> and <code>end</code> are not 987 * primary keys, they are indexes in the result set. Thus, <code>0</code> 988 * refers to the first result in the set. Setting both <code>start</code> 989 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 990 * result set. 991 * </p> 992 * 993 * @param repositoryId the primary key of the folder's repository 994 * @param parentFolderId the primary key of the folder's parent folder 995 * @param includeMountFolders whether to include mount folders for 996 third-party repositories 997 * @param start the lower bound of the range of results 998 * @param end the upper bound of the range of results (not inclusive) 999 * @param obc the comparator to order the folders (optionally 1000 <code>null</code>) 1001 * @return the range of immediate subfolders of the parent folder ordered by 1002 comparator <code>obc</code> 1003 * @throws PortalException if the parent folder could not be found 1004 */ 1005 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1006 long repositoryId, long parentFolderId, boolean includeMountFolders, 1007 int start, int end, 1008 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1009 throws com.liferay.portal.kernel.exception.PortalException { 1010 return getService() 1011 .getFolders(repositoryId, parentFolderId, 1012 includeMountFolders, start, end, obc); 1013 } 1014 1015 /** 1016 * Returns a name-ordered range of all the immediate subfolders of the 1017 * parent folder. 1018 * 1019 * <p> 1020 * Useful when paginating results. Returns a maximum of <code>end - 1021 * start</code> instances. <code>start</code> and <code>end</code> are not 1022 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1023 * refers to the first result in the set. Setting both <code>start</code> 1024 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1025 * result set. 1026 * </p> 1027 * 1028 * @param repositoryId the primary key of the folder's repository 1029 * @param parentFolderId the primary key of the folder's parent folder 1030 * @param start the lower bound of the range of results 1031 * @param end the upper bound of the range of results (not inclusive) 1032 * @return the name-ordered range of immediate subfolders of the parent 1033 folder 1034 * @throws PortalException if the parent folder could not be found 1035 */ 1036 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1037 long repositoryId, long parentFolderId, int start, int end) 1038 throws com.liferay.portal.kernel.exception.PortalException { 1039 return getService().getFolders(repositoryId, parentFolderId, start, end); 1040 } 1041 1042 /** 1043 * Returns an ordered range of all the immediate subfolders of the parent 1044 * folder. 1045 * 1046 * <p> 1047 * Useful when paginating results. Returns a maximum of <code>end - 1048 * start</code> instances. <code>start</code> and <code>end</code> are not 1049 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1050 * refers to the first result in the set. Setting both <code>start</code> 1051 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1052 * result set. 1053 * </p> 1054 * 1055 * @param repositoryId the primary key of the folder's repository 1056 * @param parentFolderId the primary key of the folder's parent folder 1057 * @param start the lower bound of the range of results 1058 * @param end the upper bound of the range of results (not inclusive) 1059 * @param obc the comparator to order the folders (optionally 1060 <code>null</code>) 1061 * @return the range of immediate subfolders of the parent folder ordered by 1062 comparator <code>obc</code> 1063 * @throws PortalException if the parent folder could not be found 1064 */ 1065 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1066 long repositoryId, long parentFolderId, int start, int end, 1067 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1068 throws com.liferay.portal.kernel.exception.PortalException { 1069 return getService() 1070 .getFolders(repositoryId, parentFolderId, start, end, obc); 1071 } 1072 1073 /** 1074 * Returns an ordered range of all the immediate subfolders of the parent 1075 * folder. 1076 * 1077 * <p> 1078 * Useful when paginating results. Returns a maximum of <code>end - 1079 * start</code> instances. <code>start</code> and <code>end</code> are not 1080 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1081 * refers to the first result in the set. Setting both <code>start</code> 1082 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1083 * result set. 1084 * </p> 1085 * 1086 * @param repositoryId the primary key of the folder's repository 1087 * @param parentFolderId the primary key of the folder's parent folder 1088 * @param status the workflow status 1089 * @param includeMountFolders whether to include mount folders for 1090 third-party repositories 1091 * @param start the lower bound of the range of results 1092 * @param end the upper bound of the range of results (not inclusive) 1093 * @param obc the comparator to order the folders (optionally 1094 <code>null</code>) 1095 * @return the range of immediate subfolders of the parent folder ordered by 1096 comparator <code>obc</code> 1097 * @throws PortalException if the parent folder could not be found 1098 */ 1099 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders( 1100 long repositoryId, long parentFolderId, int status, 1101 boolean includeMountFolders, int start, int end, 1102 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1103 throws com.liferay.portal.kernel.exception.PortalException { 1104 return getService() 1105 .getFolders(repositoryId, parentFolderId, status, 1106 includeMountFolders, start, end, obc); 1107 } 1108 1109 /** 1110 * Returns a name-ordered range of all the immediate subfolders, file 1111 * entries, and file shortcuts in the parent folder. 1112 * 1113 * <p> 1114 * Useful when paginating results. Returns a maximum of <code>end - 1115 * start</code> instances. <code>start</code> and <code>end</code> are not 1116 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1117 * refers to the first result in the set. Setting both <code>start</code> 1118 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1119 * result set. 1120 * </p> 1121 * 1122 * @param repositoryId the primary key of the repository 1123 * @param folderId the primary key of the parent folder 1124 * @param status the workflow status 1125 * @param includeMountFolders whether to include mount folders for 1126 third-party repositories 1127 * @param start the lower bound of the range of results 1128 * @param end the upper bound of the range of results (not inclusive) 1129 * @return the name-ordered range of immediate subfolders, file entries, and 1130 file shortcuts in the parent folder 1131 * @throws PortalException if the parent folder could not be found 1132 */ 1133 public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts( 1134 long repositoryId, long folderId, int status, 1135 boolean includeMountFolders, int start, int end) 1136 throws com.liferay.portal.kernel.exception.PortalException { 1137 return getService() 1138 .getFoldersAndFileEntriesAndFileShortcuts(repositoryId, 1139 folderId, status, includeMountFolders, start, end); 1140 } 1141 1142 /** 1143 * Returns an ordered range of all the immediate subfolders, file entries, 1144 * and file shortcuts in the parent folder. 1145 * 1146 * <p> 1147 * Useful when paginating results. Returns a maximum of <code>end - 1148 * start</code> instances. <code>start</code> and <code>end</code> are not 1149 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1150 * refers to the first result in the set. Setting both <code>start</code> 1151 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1152 * result set. 1153 * </p> 1154 * 1155 * @param repositoryId the primary key of the repository 1156 * @param folderId the primary key of the parent folder 1157 * @param status the workflow status 1158 * @param includeMountFolders whether to include mount folders for 1159 third-party repositories 1160 * @param start the lower bound of the range of results 1161 * @param end the upper bound of the range of results (not inclusive) 1162 * @param obc the comparator to order the results (optionally 1163 <code>null</code>) 1164 * @return the range of immediate subfolders, file entries, and file 1165 shortcuts in the parent folder ordered by comparator 1166 <code>obc</code> 1167 * @throws PortalException if the parent folder could not be found 1168 */ 1169 public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts( 1170 long repositoryId, long folderId, int status, 1171 boolean includeMountFolders, int start, int end, 1172 com.liferay.portal.kernel.util.OrderByComparator<?> obc) 1173 throws com.liferay.portal.kernel.exception.PortalException { 1174 return getService() 1175 .getFoldersAndFileEntriesAndFileShortcuts(repositoryId, 1176 folderId, status, includeMountFolders, start, end, obc); 1177 } 1178 1179 public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts( 1180 long repositoryId, long folderId, int status, 1181 java.lang.String[] mimeTypes, boolean includeMountFolders, int start, 1182 int end, com.liferay.portal.kernel.util.OrderByComparator<?> obc) 1183 throws com.liferay.portal.kernel.exception.PortalException { 1184 return getService() 1185 .getFoldersAndFileEntriesAndFileShortcuts(repositoryId, 1186 folderId, status, mimeTypes, includeMountFolders, start, end, obc); 1187 } 1188 1189 /** 1190 * Returns the number of immediate subfolders, file entries, and file 1191 * shortcuts in the parent folder. 1192 * 1193 * @param repositoryId the primary key of the repository 1194 * @param folderId the primary key of the parent folder 1195 * @param status the workflow status 1196 * @param includeMountFolders whether to include mount folders for 1197 third-party repositories 1198 * @return the number of immediate subfolders, file entries, and file 1199 shortcuts in the parent folder 1200 * @throws PortalException if the folder could not be found 1201 */ 1202 public static int getFoldersAndFileEntriesAndFileShortcutsCount( 1203 long repositoryId, long folderId, int status, 1204 boolean includeMountFolders) 1205 throws com.liferay.portal.kernel.exception.PortalException { 1206 return getService() 1207 .getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId, 1208 folderId, status, includeMountFolders); 1209 } 1210 1211 public static int getFoldersAndFileEntriesAndFileShortcutsCount( 1212 long repositoryId, long folderId, int status, 1213 java.lang.String[] mimeTypes, boolean includeMountFolders) 1214 throws com.liferay.portal.kernel.exception.PortalException { 1215 return getService() 1216 .getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId, 1217 folderId, status, mimeTypes, includeMountFolders); 1218 } 1219 1220 /** 1221 * Returns the number of immediate subfolders of the parent folder. 1222 * 1223 * @param repositoryId the primary key of the folder's repository 1224 * @param parentFolderId the primary key of the folder's parent folder 1225 * @return the number of immediate subfolders of the parent folder 1226 * @throws PortalException if the parent folder could not be found 1227 */ 1228 public static int getFoldersCount(long repositoryId, long parentFolderId) 1229 throws com.liferay.portal.kernel.exception.PortalException { 1230 return getService().getFoldersCount(repositoryId, parentFolderId); 1231 } 1232 1233 /** 1234 * Returns the number of immediate subfolders of the parent folder, 1235 * optionally including mount folders for third-party repositories. 1236 * 1237 * @param repositoryId the primary key of the folder's repository 1238 * @param parentFolderId the primary key of the folder's parent folder 1239 * @param includeMountFolders whether to include mount folders for 1240 third-party repositories 1241 * @return the number of immediate subfolders of the parent folder 1242 * @throws PortalException if the parent folder could not be found 1243 */ 1244 public static int getFoldersCount(long repositoryId, long parentFolderId, 1245 boolean includeMountFolders) 1246 throws com.liferay.portal.kernel.exception.PortalException { 1247 return getService() 1248 .getFoldersCount(repositoryId, parentFolderId, 1249 includeMountFolders); 1250 } 1251 1252 /** 1253 * Returns the number of immediate subfolders of the parent folder, 1254 * optionally including mount folders for third-party repositories. 1255 * 1256 * @param repositoryId the primary key of the folder's repository 1257 * @param parentFolderId the primary key of the folder's parent folder 1258 * @param status the workflow status 1259 * @param includeMountFolders whether to include mount folders for 1260 third-party repositories 1261 * @return the number of immediate subfolders of the parent folder 1262 * @throws PortalException if the parent folder could not be found 1263 */ 1264 public static int getFoldersCount(long repositoryId, long parentFolderId, 1265 int status, boolean includeMountFolders) 1266 throws com.liferay.portal.kernel.exception.PortalException { 1267 return getService() 1268 .getFoldersCount(repositoryId, parentFolderId, status, 1269 includeMountFolders); 1270 } 1271 1272 /** 1273 * Returns the number of immediate subfolders and file entries across the 1274 * folders. 1275 * 1276 * @param repositoryId the primary key of the repository 1277 * @param folderIds the primary keys of folders from which to count 1278 immediate subfolders and file entries 1279 * @param status the workflow status 1280 * @return the number of immediate subfolders and file entries across the 1281 folders 1282 * @throws PortalException if the repository could not be found 1283 */ 1284 public static int getFoldersFileEntriesCount(long repositoryId, 1285 java.util.List<java.lang.Long> folderIds, int status) 1286 throws com.liferay.portal.kernel.exception.PortalException { 1287 return getService() 1288 .getFoldersFileEntriesCount(repositoryId, folderIds, status); 1289 } 1290 1291 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1292 long groupId, long userId, long rootFolderId, 1293 java.lang.String[] mimeTypes, int status, int start, int end, 1294 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 1295 throws com.liferay.portal.kernel.exception.PortalException { 1296 return getService() 1297 .getGroupFileEntries(groupId, userId, rootFolderId, 1298 mimeTypes, status, start, end, obc); 1299 } 1300 1301 /** 1302 * Returns an ordered range of all the file entries in the group starting at 1303 * the root folder that are stored within the Liferay repository. This 1304 * method is primarily used to search for recently modified file entries. It 1305 * can be limited to the file entries modified by a given user. 1306 * 1307 * <p> 1308 * Useful when paginating results. Returns a maximum of <code>end - 1309 * start</code> instances. <code>start</code> and <code>end</code> are not 1310 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1311 * refers to the first result in the set. Setting both <code>start</code> 1312 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1313 * result set. 1314 * </p> 1315 * 1316 * @param groupId the primary key of the group 1317 * @param userId the primary key of the user who created the file 1318 (optionally <code>0</code>) 1319 * @param rootFolderId the primary key of the root folder to begin the 1320 search 1321 * @param start the lower bound of the range of results 1322 * @param end the upper bound of the range of results (not inclusive) 1323 * @return the range of matching file entries ordered by date modified 1324 * @throws PortalException if the group could not be found 1325 */ 1326 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1327 long groupId, long userId, long rootFolderId, int start, int end) 1328 throws com.liferay.portal.kernel.exception.PortalException { 1329 return getService() 1330 .getGroupFileEntries(groupId, userId, rootFolderId, start, 1331 end); 1332 } 1333 1334 /** 1335 * Returns an ordered range of all the file entries in the group starting at 1336 * the root folder that are stored within the Liferay repository. This 1337 * method is primarily used to search for recently modified file entries. It 1338 * can be limited to the file entries modified by a given user. 1339 * 1340 * <p> 1341 * Useful when paginating results. Returns a maximum of <code>end - 1342 * start</code> instances. <code>start</code> and <code>end</code> are not 1343 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1344 * refers to the first result in the set. Setting both <code>start</code> 1345 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1346 * result set. 1347 * </p> 1348 * 1349 * @param groupId the primary key of the group 1350 * @param userId the primary key of the user who created the file 1351 (optionally <code>0</code>) 1352 * @param rootFolderId the primary key of the root folder to begin the 1353 search 1354 * @param start the lower bound of the range of results 1355 * @param end the upper bound of the range of results (not inclusive) 1356 * @param obc the comparator to order the file entries (optionally 1357 <code>null</code>) 1358 * @return the range of matching file entries ordered by comparator 1359 <code>obc</code> 1360 * @throws PortalException if the group could not be found 1361 */ 1362 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1363 long groupId, long userId, long rootFolderId, int start, int end, 1364 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 1365 throws com.liferay.portal.kernel.exception.PortalException { 1366 return getService() 1367 .getGroupFileEntries(groupId, userId, rootFolderId, start, 1368 end, obc); 1369 } 1370 1371 /** 1372 * Returns an ordered range of all the file entries in the group starting at 1373 * the repository default parent folder that are stored within the Liferay 1374 * repository. This method is primarily used to search for recently modified 1375 * file entries. It can be limited to the file entries modified by a given 1376 * user. 1377 * 1378 * <p> 1379 * Useful when paginating results. Returns a maximum of <code>end - 1380 * start</code> instances. <code>start</code> and <code>end</code> are not 1381 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1382 * refers to the first result in the set. Setting both <code>start</code> 1383 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1384 * result set. 1385 * </p> 1386 * 1387 * @param groupId the primary key of the group 1388 * @param userId the primary key of the user who created the file 1389 (optionally <code>0</code>) 1390 * @param start the lower bound of the range of results 1391 * @param end the upper bound of the range of results (not inclusive) 1392 * @return the range of matching file entries ordered by date modified 1393 * @throws PortalException if the group could not be found 1394 */ 1395 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1396 long groupId, long userId, int start, int end) 1397 throws com.liferay.portal.kernel.exception.PortalException { 1398 return getService().getGroupFileEntries(groupId, userId, start, end); 1399 } 1400 1401 /** 1402 * Returns an ordered range of all the file entries in the group that are 1403 * stored within the Liferay repository. This method is primarily used to 1404 * search for recently modified file entries. It can be limited to the file 1405 * entries modified by a given user. 1406 * 1407 * <p> 1408 * Useful when paginating results. Returns a maximum of <code>end - 1409 * start</code> instances. <code>start</code> and <code>end</code> are not 1410 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1411 * refers to the first result in the set. Setting both <code>start</code> 1412 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1413 * result set. 1414 * </p> 1415 * 1416 * @param groupId the primary key of the group 1417 * @param userId the primary key of the user who created the file 1418 (optionally <code>0</code>) 1419 * @param start the lower bound of the range of results 1420 * @param end the upper bound of the range of results (not inclusive) 1421 * @param obc the comparator to order the file entries (optionally 1422 <code>null</code>) 1423 * @return the range of matching file entries ordered by comparator 1424 <code>obc</code> 1425 * @throws PortalException if the group could not be found 1426 */ 1427 public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries( 1428 long groupId, long userId, int start, int end, 1429 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc) 1430 throws com.liferay.portal.kernel.exception.PortalException { 1431 return getService().getGroupFileEntries(groupId, userId, start, end, obc); 1432 } 1433 1434 /** 1435 * Returns the number of file entries in a group starting at the repository 1436 * default parent folder that are stored within the Liferay repository. This 1437 * method is primarily used to search for recently modified file entries. It 1438 * can be limited to the file entries modified by a given user. 1439 * 1440 * @param groupId the primary key of the group 1441 * @param userId the primary key of the user who created the file 1442 (optionally <code>0</code>) 1443 * @return the number of matching file entries 1444 * @throws PortalException if the group could not be found 1445 */ 1446 public static int getGroupFileEntriesCount(long groupId, long userId) 1447 throws com.liferay.portal.kernel.exception.PortalException { 1448 return getService().getGroupFileEntriesCount(groupId, userId); 1449 } 1450 1451 /** 1452 * Returns the number of file entries in a group starting at the root folder 1453 * that are stored within the Liferay repository. This method is primarily 1454 * used to search for recently modified file entries. It can be limited to 1455 * the file entries modified by a given user. 1456 * 1457 * @param groupId the primary key of the group 1458 * @param userId the primary key of the user who created the file 1459 (optionally <code>0</code>) 1460 * @param rootFolderId the primary key of the root folder to begin the 1461 search 1462 * @return the number of matching file entries 1463 * @throws PortalException if the group could not be found 1464 */ 1465 public static int getGroupFileEntriesCount(long groupId, long userId, 1466 long rootFolderId) 1467 throws com.liferay.portal.kernel.exception.PortalException { 1468 return getService() 1469 .getGroupFileEntriesCount(groupId, userId, rootFolderId); 1470 } 1471 1472 public static int getGroupFileEntriesCount(long groupId, long userId, 1473 long rootFolderId, java.lang.String[] mimeTypes, int status) 1474 throws com.liferay.portal.kernel.exception.PortalException { 1475 return getService() 1476 .getGroupFileEntriesCount(groupId, userId, rootFolderId, 1477 mimeTypes, status); 1478 } 1479 1480 /** 1481 * Returns all immediate subfolders of the parent folder that are used for 1482 * mounting third-party repositories. This method is only supported by the 1483 * Liferay repository. 1484 * 1485 * @param repositoryId the primary key of the folder's repository 1486 * @param parentFolderId the primary key of the folder's parent folder 1487 * @return the immediate subfolders of the parent folder that are used for 1488 mounting third-party repositories 1489 * @throws PortalException if the repository or parent folder could not be 1490 found 1491 */ 1492 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders( 1493 long repositoryId, long parentFolderId) 1494 throws com.liferay.portal.kernel.exception.PortalException { 1495 return getService().getMountFolders(repositoryId, parentFolderId); 1496 } 1497 1498 /** 1499 * Returns a name-ordered range of all the immediate subfolders of the 1500 * parent folder that are used for mounting third-party repositories. This 1501 * method is only supported by the Liferay repository. 1502 * 1503 * <p> 1504 * Useful when paginating results. Returns a maximum of <code>end - 1505 * start</code> instances. <code>start</code> and <code>end</code> are not 1506 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1507 * refers to the first result in the set. Setting both <code>start</code> 1508 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1509 * result set. 1510 * </p> 1511 * 1512 * @param repositoryId the primary key of the repository 1513 * @param parentFolderId the primary key of the parent folder 1514 * @param start the lower bound of the range of results 1515 * @param end the upper bound of the range of results (not inclusive) 1516 * @return the name-ordered range of immediate subfolders of the parent 1517 folder that are used for mounting third-party repositories 1518 * @throws PortalException if the repository or parent folder could not be 1519 found 1520 */ 1521 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders( 1522 long repositoryId, long parentFolderId, int start, int end) 1523 throws com.liferay.portal.kernel.exception.PortalException { 1524 return getService() 1525 .getMountFolders(repositoryId, parentFolderId, start, end); 1526 } 1527 1528 /** 1529 * Returns an ordered range of all the immediate subfolders of the parent 1530 * folder that are used for mounting third-party repositories. This method 1531 * is only supported by the Liferay repository. 1532 * 1533 * <p> 1534 * Useful when paginating results. Returns a maximum of <code>end - 1535 * start</code> instances. <code>start</code> and <code>end</code> are not 1536 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1537 * refers to the first result in the set. Setting both <code>start</code> 1538 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1539 * result set. 1540 * </p> 1541 * 1542 * @param repositoryId the primary key of the folder's repository 1543 * @param parentFolderId the primary key of the folder's parent folder 1544 * @param start the lower bound of the range of results 1545 * @param end the upper bound of the range of results (not inclusive) 1546 * @param obc the comparator to order the folders (optionally 1547 <code>null</code>) 1548 * @return the range of immediate subfolders of the parent folder that are 1549 used for mounting third-party repositories ordered by comparator 1550 <code>obc</code> 1551 * @throws PortalException if the repository or parent folder could not be 1552 found 1553 */ 1554 public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders( 1555 long repositoryId, long parentFolderId, int start, int end, 1556 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc) 1557 throws com.liferay.portal.kernel.exception.PortalException { 1558 return getService() 1559 .getMountFolders(repositoryId, parentFolderId, start, end, 1560 obc); 1561 } 1562 1563 /** 1564 * Returns the number of immediate subfolders of the parent folder that are 1565 * used for mounting third-party repositories. This method is only supported 1566 * by the Liferay repository. 1567 * 1568 * @param repositoryId the primary key of the repository 1569 * @param parentFolderId the primary key of the parent folder 1570 * @return the number of folders of the parent folder that are used for 1571 mounting third-party repositories 1572 * @throws PortalException if the repository or parent folder could not be 1573 found 1574 */ 1575 public static int getMountFoldersCount(long repositoryId, 1576 long parentFolderId) 1577 throws com.liferay.portal.kernel.exception.PortalException { 1578 return getService().getMountFoldersCount(repositoryId, parentFolderId); 1579 } 1580 1581 /** 1582 * Returns all the descendant folders of the folder with the primary key. 1583 * 1584 * @param repositoryId the primary key of the repository 1585 * @param folderId the primary key of the folder 1586 * @return the descendant folders of the folder with the primary key 1587 * @throws PortalException if the repository or parent folder could not be 1588 found 1589 */ 1590 public static java.util.List<java.lang.Long> getSubfolderIds( 1591 long repositoryId, long folderId) 1592 throws com.liferay.portal.kernel.exception.PortalException { 1593 return getService().getSubfolderIds(repositoryId, folderId); 1594 } 1595 1596 /** 1597 * Returns descendant folders of the folder with the primary key, optionally 1598 * limiting to one level deep. 1599 * 1600 * @param repositoryId the primary key of the repository 1601 * @param folderId the primary key of the folder 1602 * @param recurse whether to recurse through each subfolder 1603 * @return the descendant folders of the folder with the primary key 1604 * @throws PortalException if the repository or parent folder could not be 1605 found 1606 */ 1607 public static java.util.List<java.lang.Long> getSubfolderIds( 1608 long repositoryId, long folderId, boolean recurse) 1609 throws com.liferay.portal.kernel.exception.PortalException { 1610 return getService().getSubfolderIds(repositoryId, folderId, recurse); 1611 } 1612 1613 public static void getSubfolderIds(long repositoryId, 1614 java.util.List<java.lang.Long> folderIds, long folderId) 1615 throws com.liferay.portal.kernel.exception.PortalException { 1616 getService().getSubfolderIds(repositoryId, folderIds, folderId); 1617 } 1618 1619 /** 1620 * Returns all the temporary file entry names. 1621 * 1622 * @param groupId the primary key of the group 1623 * @param folderId the primary key of the folder where the file entry will 1624 eventually reside 1625 * @param folderName the temporary folder's name 1626 * @return the temporary file entry names 1627 * @throws PortalException if the folder was invalid 1628 * @see #addTempFileEntry(long, long, String, String, File, String) 1629 * @see TempFileEntryUtil 1630 */ 1631 public static java.lang.String[] getTempFileNames(long groupId, 1632 long folderId, java.lang.String folderName) 1633 throws com.liferay.portal.kernel.exception.PortalException { 1634 return getService().getTempFileNames(groupId, folderId, folderName); 1635 } 1636 1637 /** 1638 * Locks the folder. This method is primarily used by WebDAV. 1639 * 1640 * @param repositoryId the primary key of the repository 1641 * @param folderId the primary key of the folder 1642 * @return the lock object 1643 * @throws PortalException if the repository or folder could not be found 1644 */ 1645 public static com.liferay.portal.kernel.lock.Lock lockFolder( 1646 long repositoryId, long folderId) 1647 throws com.liferay.portal.kernel.exception.PortalException { 1648 return getService().lockFolder(repositoryId, folderId); 1649 } 1650 1651 /** 1652 * Locks the folder. This method is primarily used by WebDAV. 1653 * 1654 * @param repositoryId the primary key of the repository 1655 * @param folderId the primary key of the folder 1656 * @param owner the owner string for the checkout (optionally 1657 <code>null</code>) 1658 * @param inheritable whether the lock must propagate to descendants 1659 * @param expirationTime the time in milliseconds before the lock expires. 1660 If the value is <code>0</code>, the default expiration time will 1661 be used from <code>portal.properties>. 1662 * @return the lock object 1663 * @throws PortalException if the repository or folder could not be found 1664 */ 1665 public static com.liferay.portal.kernel.lock.Lock lockFolder( 1666 long repositoryId, long folderId, java.lang.String owner, 1667 boolean inheritable, long expirationTime) 1668 throws com.liferay.portal.kernel.exception.PortalException { 1669 return getService() 1670 .lockFolder(repositoryId, folderId, owner, inheritable, 1671 expirationTime); 1672 } 1673 1674 /** 1675 * Moves the file entry to the new folder. 1676 * 1677 * @param fileEntryId the primary key of the file entry 1678 * @param newFolderId the primary key of the new folder 1679 * @param serviceContext the service context to be applied 1680 * @return the file entry 1681 * @throws PortalException if the file entry or the new folder could not be 1682 found 1683 */ 1684 public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntry( 1685 long fileEntryId, long newFolderId, 1686 com.liferay.portal.service.ServiceContext serviceContext) 1687 throws com.liferay.portal.kernel.exception.PortalException { 1688 return getService() 1689 .moveFileEntry(fileEntryId, newFolderId, serviceContext); 1690 } 1691 1692 /** 1693 * Moves the file entry from a trashed folder to the new folder. 1694 * 1695 * @param fileEntryId the primary key of the file entry 1696 * @param newFolderId the primary key of the new folder 1697 * @param serviceContext the service context to be applied 1698 * @return the file entry 1699 * @throws PortalException if the file entry or the new folder could not be 1700 found 1701 */ 1702 public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryFromTrash( 1703 long fileEntryId, long newFolderId, 1704 com.liferay.portal.service.ServiceContext serviceContext) 1705 throws com.liferay.portal.kernel.exception.PortalException { 1706 return getService() 1707 .moveFileEntryFromTrash(fileEntryId, newFolderId, 1708 serviceContext); 1709 } 1710 1711 /** 1712 * Moves the file entry with the primary key to the trash portlet. 1713 * 1714 * @param fileEntryId the primary key of the file entry 1715 * @return the file entry 1716 * @throws PortalException if the file entry could not be found 1717 */ 1718 public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryToTrash( 1719 long fileEntryId) 1720 throws com.liferay.portal.kernel.exception.PortalException { 1721 return getService().moveFileEntryToTrash(fileEntryId); 1722 } 1723 1724 /** 1725 * Moves the file shortcut from a trashed folder to the new folder. 1726 * 1727 * @param fileShortcutId the primary key of the file shortcut 1728 * @param newFolderId the primary key of the new folder 1729 * @param serviceContext the service context to be applied 1730 * @return the file shortcut 1731 * @throws PortalException if the file entry or the new folder could not be 1732 found 1733 */ 1734 public static com.liferay.portal.kernel.repository.model.FileShortcut moveFileShortcutFromTrash( 1735 long fileShortcutId, long newFolderId, 1736 com.liferay.portal.service.ServiceContext serviceContext) 1737 throws com.liferay.portal.kernel.exception.PortalException { 1738 return getService() 1739 .moveFileShortcutFromTrash(fileShortcutId, newFolderId, 1740 serviceContext); 1741 } 1742 1743 /** 1744 * Moves the file shortcut with the primary key to the trash portlet. 1745 * 1746 * @param fileShortcutId the primary key of the file shortcut 1747 * @return the file shortcut 1748 * @throws PortalException if the file shortcut could not be found 1749 */ 1750 public static com.liferay.portal.kernel.repository.model.FileShortcut moveFileShortcutToTrash( 1751 long fileShortcutId) 1752 throws com.liferay.portal.kernel.exception.PortalException { 1753 return getService().moveFileShortcutToTrash(fileShortcutId); 1754 } 1755 1756 /** 1757 * Moves the folder to the new parent folder with the primary key. 1758 * 1759 * @param folderId the primary key of the folder 1760 * @param parentFolderId the primary key of the new parent folder 1761 * @param serviceContext the service context to be applied 1762 * @return the file entry 1763 * @throws PortalException if the folder could not be found 1764 */ 1765 public static com.liferay.portal.kernel.repository.model.Folder moveFolder( 1766 long folderId, long parentFolderId, 1767 com.liferay.portal.service.ServiceContext serviceContext) 1768 throws com.liferay.portal.kernel.exception.PortalException { 1769 return getService().moveFolder(folderId, parentFolderId, serviceContext); 1770 } 1771 1772 /** 1773 * Moves the folder with the primary key from the trash portlet to the new 1774 * parent folder with the primary key. 1775 * 1776 * @param folderId the primary key of the folder 1777 * @param parentFolderId the primary key of the new parent folder 1778 * @param serviceContext the service context to be applied 1779 * @return the file entry 1780 * @throws PortalException if the folder could not be found 1781 */ 1782 public static com.liferay.portal.kernel.repository.model.Folder moveFolderFromTrash( 1783 long folderId, long parentFolderId, 1784 com.liferay.portal.service.ServiceContext serviceContext) 1785 throws com.liferay.portal.kernel.exception.PortalException { 1786 return getService() 1787 .moveFolderFromTrash(folderId, parentFolderId, serviceContext); 1788 } 1789 1790 /** 1791 * Moves the folder with the primary key to the trash portlet. 1792 * 1793 * @param folderId the primary key of the folder 1794 * @return the file entry 1795 * @throws PortalException if the folder could not be found 1796 */ 1797 public static com.liferay.portal.kernel.repository.model.Folder moveFolderToTrash( 1798 long folderId) 1799 throws com.liferay.portal.kernel.exception.PortalException { 1800 return getService().moveFolderToTrash(folderId); 1801 } 1802 1803 /** 1804 * Refreshes the lock for the file entry. This method is primarily used by 1805 * WebDAV. 1806 * 1807 * @param lockUuid the lock's UUID 1808 * @param companyId the primary key of the file entry's company 1809 * @param expirationTime the time in milliseconds before the lock expires. 1810 If the value is <code>0</code>, the default expiration time will 1811 be used from <code>portal.properties>. 1812 * @return the lock object 1813 * @throws PortalException if the file entry or lock could not be found 1814 */ 1815 public static com.liferay.portal.kernel.lock.Lock refreshFileEntryLock( 1816 java.lang.String lockUuid, long companyId, long expirationTime) 1817 throws com.liferay.portal.kernel.exception.PortalException { 1818 return getService() 1819 .refreshFileEntryLock(lockUuid, companyId, expirationTime); 1820 } 1821 1822 /** 1823 * Refreshes the lock for the folder. This method is primarily used by 1824 * WebDAV. 1825 * 1826 * @param lockUuid the lock's UUID 1827 * @param companyId the primary key of the file entry's company 1828 * @param expirationTime the time in milliseconds before the lock expires. 1829 If the value is <code>0</code>, the default expiration time will 1830 be used from <code>portal.properties>. 1831 * @return the lock object 1832 * @throws PortalException if the folder or lock could not be found 1833 */ 1834 public static com.liferay.portal.kernel.lock.Lock refreshFolderLock( 1835 java.lang.String lockUuid, long companyId, long expirationTime) 1836 throws com.liferay.portal.kernel.exception.PortalException { 1837 return getService() 1838 .refreshFolderLock(lockUuid, companyId, expirationTime); 1839 } 1840 1841 /** 1842 * Restores the file entry with the primary key from the trash portlet. 1843 * 1844 * @param fileEntryId the primary key of the file entry 1845 * @throws PortalException if the file entry could not be found 1846 */ 1847 public static void restoreFileEntryFromTrash(long fileEntryId) 1848 throws com.liferay.portal.kernel.exception.PortalException { 1849 getService().restoreFileEntryFromTrash(fileEntryId); 1850 } 1851 1852 /** 1853 * Restores the file shortcut with the primary key from the trash portlet. 1854 * 1855 * @param fileShortcutId the primary key of the file shortcut 1856 * @throws PortalException if the file shortcut could not be found 1857 */ 1858 public static void restoreFileShortcutFromTrash(long fileShortcutId) 1859 throws com.liferay.portal.kernel.exception.PortalException { 1860 getService().restoreFileShortcutFromTrash(fileShortcutId); 1861 } 1862 1863 /** 1864 * Restores the folder with the primary key from the trash portlet. 1865 * 1866 * @param folderId the primary key of the folder 1867 * @throws PortalException if the folder could not be found 1868 */ 1869 public static void restoreFolderFromTrash(long folderId) 1870 throws com.liferay.portal.kernel.exception.PortalException { 1871 getService().restoreFolderFromTrash(folderId); 1872 } 1873 1874 /** 1875 * Reverts the file entry to a previous version. A new version will be 1876 * created based on the previous version and metadata. 1877 * 1878 * @param fileEntryId the primary key of the file entry 1879 * @param version the version to revert back to 1880 * @param serviceContext the service context to be applied 1881 * @throws PortalException if the file entry or version could not be found 1882 */ 1883 public static void revertFileEntry(long fileEntryId, 1884 java.lang.String version, 1885 com.liferay.portal.service.ServiceContext serviceContext) 1886 throws com.liferay.portal.kernel.exception.PortalException { 1887 getService().revertFileEntry(fileEntryId, version, serviceContext); 1888 } 1889 1890 public static com.liferay.portal.kernel.search.Hits search( 1891 long repositoryId, long creatorUserId, long folderId, 1892 java.lang.String[] mimeTypes, int status, int start, int end) 1893 throws com.liferay.portal.kernel.exception.PortalException { 1894 return getService() 1895 .search(repositoryId, creatorUserId, folderId, mimeTypes, 1896 status, start, end); 1897 } 1898 1899 public static com.liferay.portal.kernel.search.Hits search( 1900 long repositoryId, long creatorUserId, int status, int start, int end) 1901 throws com.liferay.portal.kernel.exception.PortalException { 1902 return getService() 1903 .search(repositoryId, creatorUserId, status, start, end); 1904 } 1905 1906 public static com.liferay.portal.kernel.search.Hits search( 1907 long repositoryId, 1908 com.liferay.portal.kernel.search.SearchContext searchContext) 1909 throws com.liferay.portal.kernel.search.SearchException { 1910 return getService().search(repositoryId, searchContext); 1911 } 1912 1913 public static com.liferay.portal.kernel.search.Hits search( 1914 long repositoryId, 1915 com.liferay.portal.kernel.search.SearchContext searchContext, 1916 com.liferay.portal.kernel.search.Query query) 1917 throws com.liferay.portal.kernel.search.SearchException { 1918 return getService().search(repositoryId, searchContext, query); 1919 } 1920 1921 /** 1922 * Sets the Spring bean ID for this bean. 1923 * 1924 * @param beanIdentifier the Spring bean ID for this bean 1925 */ 1926 public static void setBeanIdentifier(java.lang.String beanIdentifier) { 1927 getService().setBeanIdentifier(beanIdentifier); 1928 } 1929 1930 /** 1931 * Subscribe the user to changes in documents of the file entry type. This 1932 * method is only supported by the Liferay repository. 1933 * 1934 * @param groupId the primary key of the file entry type's group 1935 * @param fileEntryTypeId the primary key of the file entry type 1936 * @throws PortalException if the user or group could not be found, or if 1937 subscribing was not permissible 1938 */ 1939 public static void subscribeFileEntryType(long groupId, long fileEntryTypeId) 1940 throws com.liferay.portal.kernel.exception.PortalException { 1941 getService().subscribeFileEntryType(groupId, fileEntryTypeId); 1942 } 1943 1944 /** 1945 * Subscribe the user to document changes in the folder. This method is only 1946 * supported by the Liferay repository. 1947 * 1948 * @param groupId the primary key of the folder's group 1949 * @param folderId the primary key of the folder 1950 * @throws PortalException if the user or group could not be found, or if 1951 subscribing was not permissible 1952 */ 1953 public static void subscribeFolder(long groupId, long folderId) 1954 throws com.liferay.portal.kernel.exception.PortalException { 1955 getService().subscribeFolder(groupId, folderId); 1956 } 1957 1958 /** 1959 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 1960 boolean, String, ServiceContext)}. 1961 */ 1962 @Deprecated 1963 public static void unlockFileEntry(long fileEntryId) 1964 throws com.liferay.portal.kernel.exception.PortalException { 1965 getService().unlockFileEntry(fileEntryId); 1966 } 1967 1968 /** 1969 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 1970 String)}. 1971 */ 1972 @Deprecated 1973 public static void unlockFileEntry(long fileEntryId, 1974 java.lang.String lockUuid) 1975 throws com.liferay.portal.kernel.exception.PortalException { 1976 getService().unlockFileEntry(fileEntryId, lockUuid); 1977 } 1978 1979 /** 1980 * Unlocks the folder. This method is primarily used by WebDAV. 1981 * 1982 * @param repositoryId the primary key of the repository 1983 * @param folderId the primary key of the folder 1984 * @param lockUuid the lock's UUID 1985 * @throws PortalException if the repository or folder could not be found 1986 */ 1987 public static void unlockFolder(long repositoryId, long folderId, 1988 java.lang.String lockUuid) 1989 throws com.liferay.portal.kernel.exception.PortalException { 1990 getService().unlockFolder(repositoryId, folderId, lockUuid); 1991 } 1992 1993 /** 1994 * Unlocks the folder. This method is primarily used by WebDAV. 1995 * 1996 * @param repositoryId the primary key of the repository 1997 * @param parentFolderId the primary key of the parent folder 1998 * @param name the folder's name 1999 * @param lockUuid the lock's UUID 2000 * @throws PortalException if the repository or folder could not be found 2001 */ 2002 public static void unlockFolder(long repositoryId, long parentFolderId, 2003 java.lang.String name, java.lang.String lockUuid) 2004 throws com.liferay.portal.kernel.exception.PortalException { 2005 getService().unlockFolder(repositoryId, parentFolderId, name, lockUuid); 2006 } 2007 2008 /** 2009 * Unsubscribe the user from changes in documents of the file entry type. 2010 * This method is only supported by the Liferay repository. 2011 * 2012 * @param groupId the primary key of the file entry type's group 2013 * @param fileEntryTypeId the primary key of the file entry type 2014 * @throws PortalException if the user or group could not be found, or if 2015 unsubscribing was not permissible 2016 */ 2017 public static void unsubscribeFileEntryType(long groupId, 2018 long fileEntryTypeId) 2019 throws com.liferay.portal.kernel.exception.PortalException { 2020 getService().unsubscribeFileEntryType(groupId, fileEntryTypeId); 2021 } 2022 2023 /** 2024 * Unsubscribe the user from document changes in the folder. This method is 2025 * only supported by the Liferay repository. 2026 * 2027 * @param groupId the primary key of the folder's group 2028 * @param folderId the primary key of the folder 2029 * @throws PortalException if the user or group could not be found, or if 2030 unsubscribing was not permissible 2031 */ 2032 public static void unsubscribeFolder(long groupId, long folderId) 2033 throws com.liferay.portal.kernel.exception.PortalException { 2034 getService().unsubscribeFolder(groupId, folderId); 2035 } 2036 2037 /** 2038 * Updates a file entry and associated metadata based on a byte array 2039 * object. If the file data is <code>null</code>, then only the associated 2040 * metadata (i.e., <code>title</code>, <code>description</code>, and 2041 * parameters in the <code>serviceContext</code>) will be updated. 2042 * 2043 * <p> 2044 * This method takes two file names, the <code>sourceFileName</code> and the 2045 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2046 * name of the actual file being uploaded. The <code>title</code> 2047 * corresponds to a name the client wishes to assign this file after it has 2048 * been uploaded to the portal. 2049 * </p> 2050 * 2051 * @param fileEntryId the primary key of the file entry 2052 * @param sourceFileName the original file's name (optionally 2053 <code>null</code>) 2054 * @param mimeType the file's MIME type (optionally <code>null</code>) 2055 * @param title the new name to be assigned to the file (optionally <code> 2056 <code>null</code></code>) 2057 * @param description the file's new description 2058 * @param changeLog the file's version change log (optionally 2059 <code>null</code>) 2060 * @param majorVersion whether the new file version is a major version 2061 * @param bytes the file's data (optionally <code>null</code>) 2062 * @param serviceContext the service context to be applied. Can set the 2063 asset category IDs, asset tag names, and expando bridge 2064 attributes for the file entry. In a Liferay repository, it may 2065 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2066 type </li> <li> fieldsMap - mapping for fields associated with a 2067 custom file entry type </li> </ul> 2068 * @return the file entry 2069 * @throws PortalException if the file entry could not be found 2070 */ 2071 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry( 2072 long fileEntryId, java.lang.String sourceFileName, 2073 java.lang.String mimeType, java.lang.String title, 2074 java.lang.String description, java.lang.String changeLog, 2075 boolean majorVersion, byte[] bytes, 2076 com.liferay.portal.service.ServiceContext serviceContext) 2077 throws com.liferay.portal.kernel.exception.PortalException { 2078 return getService() 2079 .updateFileEntry(fileEntryId, sourceFileName, mimeType, 2080 title, description, changeLog, majorVersion, bytes, serviceContext); 2081 } 2082 2083 /** 2084 * Updates a file entry and associated metadata based on a {@link File} 2085 * object. If the file data is <code>null</code>, then only the associated 2086 * metadata (i.e., <code>title</code>, <code>description</code>, and 2087 * parameters in the <code>serviceContext</code>) will be updated. 2088 * 2089 * <p> 2090 * This method takes two file names, the <code>sourceFileName</code> and the 2091 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2092 * name of the actual file being uploaded. The <code>title</code> 2093 * corresponds to a name the client wishes to assign this file after it has 2094 * been uploaded to the portal. 2095 * </p> 2096 * 2097 * @param fileEntryId the primary key of the file entry 2098 * @param sourceFileName the original file's name (optionally 2099 <code>null</code>) 2100 * @param mimeType the file's MIME type (optionally <code>null</code>) 2101 * @param title the new name to be assigned to the file (optionally <code> 2102 <code>null</code></code>) 2103 * @param description the file's new description 2104 * @param changeLog the file's version change log (optionally 2105 <code>null</code>) 2106 * @param majorVersion whether the new file version is a major version 2107 * @param file the file's data (optionally <code>null</code>) 2108 * @param serviceContext the service context to be applied. Can set the 2109 asset category IDs, asset tag names, and expando bridge 2110 attributes for the file entry. In a Liferay repository, it may 2111 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2112 type </li> <li> fieldsMap - mapping for fields associated with a 2113 custom file entry type </li> </ul> 2114 * @return the file entry 2115 * @throws PortalException if the file entry could not be found 2116 */ 2117 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry( 2118 long fileEntryId, java.lang.String sourceFileName, 2119 java.lang.String mimeType, java.lang.String title, 2120 java.lang.String description, java.lang.String changeLog, 2121 boolean majorVersion, java.io.File file, 2122 com.liferay.portal.service.ServiceContext serviceContext) 2123 throws com.liferay.portal.kernel.exception.PortalException { 2124 return getService() 2125 .updateFileEntry(fileEntryId, sourceFileName, mimeType, 2126 title, description, changeLog, majorVersion, file, serviceContext); 2127 } 2128 2129 /** 2130 * Updates a file entry and associated metadata based on an {@link 2131 * InputStream} object. If the file data is <code>null</code>, then only the 2132 * associated metadata (i.e., <code>title</code>, <code>description</code>, 2133 * and parameters in the <code>serviceContext</code>) will be updated. 2134 * 2135 * <p> 2136 * This method takes two file names, the <code>sourceFileName</code> and the 2137 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2138 * name of the actual file being uploaded. The <code>title</code> 2139 * corresponds to a name the client wishes to assign this file after it has 2140 * been uploaded to the portal. 2141 * </p> 2142 * 2143 * @param fileEntryId the primary key of the file entry 2144 * @param sourceFileName the original file's name (optionally 2145 <code>null</code>) 2146 * @param mimeType the file's MIME type (optionally <code>null</code>) 2147 * @param title the new name to be assigned to the file (optionally <code> 2148 <code>null</code></code>) 2149 * @param description the file's new description 2150 * @param changeLog the file's version change log (optionally 2151 <code>null</code>) 2152 * @param majorVersion whether the new file version is a major version 2153 * @param is the file's data (optionally <code>null</code>) 2154 * @param size the file's size (optionally <code>0</code>) 2155 * @param serviceContext the service context to be applied. Can set the 2156 asset category IDs, asset tag names, and expando bridge 2157 attributes for the file entry. In a Liferay repository, it may 2158 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2159 type </li> <li> fieldsMap - mapping for fields associated with a 2160 custom file entry type </li> </ul> 2161 * @return the file entry 2162 * @throws PortalException if the file entry could not be found 2163 */ 2164 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry( 2165 long fileEntryId, java.lang.String sourceFileName, 2166 java.lang.String mimeType, java.lang.String title, 2167 java.lang.String description, java.lang.String changeLog, 2168 boolean majorVersion, java.io.InputStream is, long size, 2169 com.liferay.portal.service.ServiceContext serviceContext) 2170 throws com.liferay.portal.kernel.exception.PortalException { 2171 return getService() 2172 .updateFileEntry(fileEntryId, sourceFileName, mimeType, 2173 title, description, changeLog, majorVersion, is, size, 2174 serviceContext); 2175 } 2176 2177 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn( 2178 long fileEntryId, java.lang.String sourceFileName, 2179 java.lang.String mimeType, java.lang.String title, 2180 java.lang.String description, java.lang.String changeLog, 2181 boolean majorVersion, java.io.File file, 2182 com.liferay.portal.service.ServiceContext serviceContext) 2183 throws com.liferay.portal.kernel.exception.PortalException { 2184 return getService() 2185 .updateFileEntryAndCheckIn(fileEntryId, sourceFileName, 2186 mimeType, title, description, changeLog, majorVersion, file, 2187 serviceContext); 2188 } 2189 2190 public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn( 2191 long fileEntryId, java.lang.String sourceFileName, 2192 java.lang.String mimeType, java.lang.String title, 2193 java.lang.String description, java.lang.String changeLog, 2194 boolean majorVersion, java.io.InputStream is, long size, 2195 com.liferay.portal.service.ServiceContext serviceContext) 2196 throws com.liferay.portal.kernel.exception.PortalException { 2197 return getService() 2198 .updateFileEntryAndCheckIn(fileEntryId, sourceFileName, 2199 mimeType, title, description, changeLog, majorVersion, is, size, 2200 serviceContext); 2201 } 2202 2203 /** 2204 * Updates a file shortcut to the existing file entry. This method is only 2205 * supported by the Liferay repository. 2206 * 2207 * @param fileShortcutId the primary key of the file shortcut 2208 * @param folderId the primary key of the file shortcut's parent folder 2209 * @param toFileEntryId the primary key of the file shortcut's file entry 2210 * @param serviceContext the service context to be applied. Can set the 2211 asset category IDs, asset tag names, and expando bridge 2212 attributes for the file entry. 2213 * @return the file shortcut 2214 * @throws PortalException if the file shortcut, folder, or file entry could 2215 not be found 2216 */ 2217 public static com.liferay.portal.kernel.repository.model.FileShortcut updateFileShortcut( 2218 long fileShortcutId, long folderId, long toFileEntryId, 2219 com.liferay.portal.service.ServiceContext serviceContext) 2220 throws com.liferay.portal.kernel.exception.PortalException { 2221 return getService() 2222 .updateFileShortcut(fileShortcutId, folderId, toFileEntryId, 2223 serviceContext); 2224 } 2225 2226 /** 2227 * Updates the folder. 2228 * 2229 * @param folderId the primary key of the folder 2230 * @param name the folder's new name 2231 * @param description the folder's new description 2232 * @param serviceContext the service context to be applied. In a Liferay 2233 repository, it may include: <ul> <li> defaultFileEntryTypeId - 2234 the file entry type to default all Liferay file entries to </li> 2235 <li> dlFileEntryTypesSearchContainerPrimaryKeys - a 2236 comma-delimited list of file entry type primary keys allowed in 2237 the given folder and all descendants </li> <li> restrictionType - 2238 specifying restriction type of file entry types allowed </li> 2239 <li> workflowDefinitionXYZ - the workflow definition name 2240 specified per file entry type. The parameter name must be the 2241 string <code>workflowDefinition</code> appended by the 2242 <code>fileEntryTypeId</code> (optionally <code>0</code>).</li> 2243 </ul> 2244 * @return the folder 2245 * @throws PortalException if the current or new parent folder could not be 2246 found or if the new parent folder's information was invalid 2247 */ 2248 public static com.liferay.portal.kernel.repository.model.Folder updateFolder( 2249 long folderId, java.lang.String name, java.lang.String description, 2250 com.liferay.portal.service.ServiceContext serviceContext) 2251 throws com.liferay.portal.kernel.exception.PortalException { 2252 return getService() 2253 .updateFolder(folderId, name, description, serviceContext); 2254 } 2255 2256 /** 2257 * Returns <code>true</code> if the file entry is checked out. This method 2258 * is primarily used by WebDAV. 2259 * 2260 * @param repositoryId the primary key for the repository 2261 * @param fileEntryId the primary key for the file entry 2262 * @param lockUuid the lock's UUID 2263 * @return <code>true</code> if the file entry is checked out; 2264 <code>false</code> otherwise 2265 * @throws PortalException if the file entry could not be found 2266 */ 2267 public static boolean verifyFileEntryCheckOut(long repositoryId, 2268 long fileEntryId, java.lang.String lockUuid) 2269 throws com.liferay.portal.kernel.exception.PortalException { 2270 return getService() 2271 .verifyFileEntryCheckOut(repositoryId, fileEntryId, lockUuid); 2272 } 2273 2274 public static boolean verifyFileEntryLock(long repositoryId, 2275 long fileEntryId, java.lang.String lockUuid) 2276 throws com.liferay.portal.kernel.exception.PortalException { 2277 return getService() 2278 .verifyFileEntryLock(repositoryId, fileEntryId, lockUuid); 2279 } 2280 2281 /** 2282 * Returns <code>true</code> if the inheritable lock exists. This method is 2283 * primarily used by WebDAV. 2284 * 2285 * @param repositoryId the primary key for the repository 2286 * @param folderId the primary key for the folder 2287 * @param lockUuid the lock's UUID 2288 * @return <code>true</code> if the inheritable lock exists; 2289 <code>false</code> otherwise 2290 * @throws PortalException if the folder could not be found 2291 */ 2292 public static boolean verifyInheritableLock(long repositoryId, 2293 long folderId, java.lang.String lockUuid) 2294 throws com.liferay.portal.kernel.exception.PortalException { 2295 return getService() 2296 .verifyInheritableLock(repositoryId, folderId, lockUuid); 2297 } 2298 2299 public static DLAppService getService() { 2300 if (_service == null) { 2301 _service = (DLAppService)PortalBeanLocatorUtil.locate(DLAppService.class.getName()); 2302 2303 ReferenceRegistry.registerReference(DLAppServiceUtil.class, 2304 "_service"); 2305 } 2306 2307 return _service; 2308 } 2309 2310 /** 2311 * @deprecated As of 6.2.0 2312 */ 2313 @Deprecated 2314 public void setService(DLAppService service) { 2315 } 2316 2317 private static DLAppService _service; 2318 }