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