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 name-ordered 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 name-ordered 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 name-ordered range of all the file entries with the file entry 699 * type in the 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 name-ordered range of 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 name-ordered range of all the immediate subfolders of the 1079 * parent folder, optionally including mount folders for third-party 1080 * repositories. 1081 * 1082 * <p> 1083 * Useful when paginating results. Returns a maximum of <code>end - 1084 * start</code> instances. <code>start</code> and <code>end</code> are not 1085 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1086 * refers to the first result in the set. Setting both <code>start</code> 1087 * and <code>end</code> to {@link 1088 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1089 * result set. 1090 * </p> 1091 * 1092 * @param repositoryId the primary key of the folder's repository 1093 * @param parentFolderId the primary key of the folder's parent folder 1094 * @param includeMountFolders whether to include mount folders for 1095 third-party repositories 1096 * @param start the lower bound of the range of results 1097 * @param end the upper bound of the range of results (not inclusive) 1098 * @return the name-ordered range of immediate subfolders of the parent 1099 folder 1100 * @throws PortalException if the parent folder could not be found 1101 * @throws SystemException if a system exception occurred 1102 */ 1103 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders( 1104 long repositoryId, long parentFolderId, boolean includeMountFolders, 1105 int start, int end) throws RemoteException { 1106 try { 1107 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1108 DLAppServiceUtil.getFolders(repositoryId, parentFolderId, 1109 includeMountFolders, start, end); 1110 1111 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1112 } 1113 catch (Exception e) { 1114 _log.error(e, e); 1115 1116 throw new RemoteException(e.getMessage()); 1117 } 1118 } 1119 1120 /** 1121 * Returns an ordered range of all the immediate subfolders of the parent 1122 * folder. 1123 * 1124 * <p> 1125 * Useful when paginating results. Returns a maximum of <code>end - 1126 * start</code> instances. <code>start</code> and <code>end</code> are not 1127 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1128 * refers to the first result in the set. Setting both <code>start</code> 1129 * and <code>end</code> to {@link 1130 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1131 * result set. 1132 * </p> 1133 * 1134 * @param repositoryId the primary key of the folder's repository 1135 * @param parentFolderId the primary key of the folder's parent folder 1136 * @param includeMountFolders whether to include mount folders for 1137 third-party repositories 1138 * @param start the lower bound of the range of results 1139 * @param end the upper bound of the range of results (not inclusive) 1140 * @param obc the comparator to order the folders (optionally 1141 <code>null</code>) 1142 * @return the range of immediate subfolders of the parent folder ordered by 1143 comparator <code>obc</code> 1144 * @throws PortalException if the parent folder could not be found 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders( 1148 long repositoryId, long parentFolderId, boolean includeMountFolders, 1149 int start, int end, com.liferay.portal.kernel.util.OrderByComparator obc) 1150 throws RemoteException { 1151 try { 1152 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1153 DLAppServiceUtil.getFolders(repositoryId, parentFolderId, 1154 includeMountFolders, start, end, obc); 1155 1156 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1157 } 1158 catch (Exception e) { 1159 _log.error(e, e); 1160 1161 throw new RemoteException(e.getMessage()); 1162 } 1163 } 1164 1165 /** 1166 * Returns an ordered range of all the immediate subfolders of the parent 1167 * folder. 1168 * 1169 * <p> 1170 * Useful when paginating results. Returns a maximum of <code>end - 1171 * start</code> instances. <code>start</code> and <code>end</code> are not 1172 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1173 * refers to the first result in the set. Setting both <code>start</code> 1174 * and <code>end</code> to {@link 1175 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1176 * result set. 1177 * </p> 1178 * 1179 * @param repositoryId the primary key of the folder's repository 1180 * @param parentFolderId the primary key of the folder's parent folder 1181 * @param status the workflow status 1182 * @param includeMountFolders whether to include mount folders for 1183 third-party repositories 1184 * @param start the lower bound of the range of results 1185 * @param end the upper bound of the range of results (not inclusive) 1186 * @param obc the comparator to order the folders (optionally 1187 <code>null</code>) 1188 * @return the range of immediate subfolders of the parent folder ordered by 1189 comparator <code>obc</code> 1190 * @throws PortalException if the parent folder could not be found 1191 * @throws SystemException if a system exception occurred 1192 */ 1193 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders( 1194 long repositoryId, long parentFolderId, int status, 1195 boolean includeMountFolders, int start, int end, 1196 com.liferay.portal.kernel.util.OrderByComparator obc) 1197 throws RemoteException { 1198 try { 1199 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1200 DLAppServiceUtil.getFolders(repositoryId, parentFolderId, 1201 status, includeMountFolders, start, end, obc); 1202 1203 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1204 } 1205 catch (Exception e) { 1206 _log.error(e, e); 1207 1208 throw new RemoteException(e.getMessage()); 1209 } 1210 } 1211 1212 /** 1213 * Returns a name-ordered range of all the immediate subfolders of the 1214 * parent folder. 1215 * 1216 * <p> 1217 * Useful when paginating results. Returns a maximum of <code>end - 1218 * start</code> instances. <code>start</code> and <code>end</code> are not 1219 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1220 * refers to the first result in the set. Setting both <code>start</code> 1221 * and <code>end</code> to {@link 1222 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1223 * result set. 1224 * </p> 1225 * 1226 * @param repositoryId the primary key of the folder's repository 1227 * @param parentFolderId the primary key of the folder's parent folder 1228 * @param start the lower bound of the range of results 1229 * @param end the upper bound of the range of results (not inclusive) 1230 * @return the name-ordered range of immediate subfolders of the parent 1231 folder 1232 * @throws PortalException if the parent folder could not be found 1233 * @throws SystemException if a system exception occurred 1234 */ 1235 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders( 1236 long repositoryId, long parentFolderId, int start, int end) 1237 throws RemoteException { 1238 try { 1239 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1240 DLAppServiceUtil.getFolders(repositoryId, parentFolderId, 1241 start, end); 1242 1243 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1244 } 1245 catch (Exception e) { 1246 _log.error(e, e); 1247 1248 throw new RemoteException(e.getMessage()); 1249 } 1250 } 1251 1252 /** 1253 * Returns an ordered range of all the immediate subfolders of the parent 1254 * folder. 1255 * 1256 * <p> 1257 * Useful when paginating results. Returns a maximum of <code>end - 1258 * start</code> instances. <code>start</code> and <code>end</code> are not 1259 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1260 * refers to the first result in the set. Setting both <code>start</code> 1261 * and <code>end</code> to {@link 1262 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1263 * result set. 1264 * </p> 1265 * 1266 * @param repositoryId the primary key of the folder's repository 1267 * @param parentFolderId the primary key of the folder's parent folder 1268 * @param start the lower bound of the range of results 1269 * @param end the upper bound of the range of results (not inclusive) 1270 * @param obc the comparator to order the folders (optionally 1271 <code>null</code>) 1272 * @return the range of immediate subfolders of the parent folder ordered by 1273 comparator <code>obc</code> 1274 * @throws PortalException if the parent folder could not be found 1275 * @throws SystemException if a system exception occurred 1276 */ 1277 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders( 1278 long repositoryId, long parentFolderId, int start, int end, 1279 com.liferay.portal.kernel.util.OrderByComparator obc) 1280 throws RemoteException { 1281 try { 1282 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1283 DLAppServiceUtil.getFolders(repositoryId, parentFolderId, 1284 start, end, obc); 1285 1286 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1287 } 1288 catch (Exception e) { 1289 _log.error(e, e); 1290 1291 throw new RemoteException(e.getMessage()); 1292 } 1293 } 1294 1295 /** 1296 * Returns the number of immediate subfolders, file entries, and file 1297 * shortcuts in the parent folder. 1298 * 1299 * @param repositoryId the primary key of the repository 1300 * @param folderId the primary key of the parent folder 1301 * @param status the workflow status 1302 * @param includeMountFolders whether to include mount folders for 1303 third-party repositories 1304 * @return the number of immediate subfolders, file entries, and file 1305 shortcuts in the parent folder 1306 * @throws PortalException if the folder could not be found 1307 * @throws SystemException if a system exception occurred 1308 */ 1309 public static int getFoldersAndFileEntriesAndFileShortcutsCount( 1310 long repositoryId, long folderId, int status, 1311 boolean includeMountFolders) throws RemoteException { 1312 try { 1313 int returnValue = DLAppServiceUtil.getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId, 1314 folderId, status, includeMountFolders); 1315 1316 return returnValue; 1317 } 1318 catch (Exception e) { 1319 _log.error(e, e); 1320 1321 throw new RemoteException(e.getMessage()); 1322 } 1323 } 1324 1325 public static int getFoldersAndFileEntriesAndFileShortcutsCount( 1326 long repositoryId, long folderId, int status, 1327 java.lang.String[] mimeTypes, boolean includeMountFolders) 1328 throws RemoteException { 1329 try { 1330 int returnValue = DLAppServiceUtil.getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId, 1331 folderId, status, mimeTypes, includeMountFolders); 1332 1333 return returnValue; 1334 } 1335 catch (Exception e) { 1336 _log.error(e, e); 1337 1338 throw new RemoteException(e.getMessage()); 1339 } 1340 } 1341 1342 /** 1343 * Returns the number of immediate subfolders of the parent folder. 1344 * 1345 * @param repositoryId the primary key of the folder's repository 1346 * @param parentFolderId the primary key of the folder's parent folder 1347 * @return the number of immediate subfolders of the parent folder 1348 * @throws PortalException if the parent folder could not be found 1349 * @throws SystemException if a system exception occurred 1350 */ 1351 public static int getFoldersCount(long repositoryId, long parentFolderId) 1352 throws RemoteException { 1353 try { 1354 int returnValue = DLAppServiceUtil.getFoldersCount(repositoryId, 1355 parentFolderId); 1356 1357 return returnValue; 1358 } 1359 catch (Exception e) { 1360 _log.error(e, e); 1361 1362 throw new RemoteException(e.getMessage()); 1363 } 1364 } 1365 1366 /** 1367 * Returns the number of immediate subfolders of the parent folder, 1368 * optionally including mount folders for third-party repositories. 1369 * 1370 * @param repositoryId the primary key of the folder's repository 1371 * @param parentFolderId the primary key of the folder's parent folder 1372 * @param includeMountFolders whether to include mount folders for 1373 third-party repositories 1374 * @return the number of immediate subfolders of the parent folder 1375 * @throws PortalException if the parent folder could not be found 1376 * @throws SystemException if a system exception occurred 1377 */ 1378 public static int getFoldersCount(long repositoryId, long parentFolderId, 1379 boolean includeMountFolders) throws RemoteException { 1380 try { 1381 int returnValue = DLAppServiceUtil.getFoldersCount(repositoryId, 1382 parentFolderId, includeMountFolders); 1383 1384 return returnValue; 1385 } 1386 catch (Exception e) { 1387 _log.error(e, e); 1388 1389 throw new RemoteException(e.getMessage()); 1390 } 1391 } 1392 1393 /** 1394 * Returns the number of immediate subfolders of the parent folder, 1395 * optionally including mount folders for third-party repositories. 1396 * 1397 * @param repositoryId the primary key of the folder's repository 1398 * @param parentFolderId the primary key of the folder's parent folder 1399 * @param status the workflow status 1400 * @param includeMountFolders whether to include mount folders for 1401 third-party repositories 1402 * @return the number of immediate subfolders of the parent folder 1403 * @throws PortalException if the parent folder could not be found 1404 * @throws SystemException if a system exception occurred 1405 */ 1406 public static int getFoldersCount(long repositoryId, long parentFolderId, 1407 int status, boolean includeMountFolders) throws RemoteException { 1408 try { 1409 int returnValue = DLAppServiceUtil.getFoldersCount(repositoryId, 1410 parentFolderId, status, includeMountFolders); 1411 1412 return returnValue; 1413 } 1414 catch (Exception e) { 1415 _log.error(e, e); 1416 1417 throw new RemoteException(e.getMessage()); 1418 } 1419 } 1420 1421 /** 1422 * Returns the number of immediate subfolders and file entries across the 1423 * folders. 1424 * 1425 * @param repositoryId the primary key of the repository 1426 * @param folderIds the primary keys of folders from which to count 1427 immediate subfolders and file entries 1428 * @param status the workflow status 1429 * @return the number of immediate subfolders and file entries across the 1430 folders 1431 * @throws PortalException if the repository could not be found 1432 * @throws SystemException if a system exception occurred 1433 */ 1434 public static int getFoldersFileEntriesCount(long repositoryId, 1435 Long[] folderIds, int status) throws RemoteException { 1436 try { 1437 int returnValue = DLAppServiceUtil.getFoldersFileEntriesCount(repositoryId, 1438 ListUtil.toList(folderIds), status); 1439 1440 return returnValue; 1441 } 1442 catch (Exception e) { 1443 _log.error(e, e); 1444 1445 throw new RemoteException(e.getMessage()); 1446 } 1447 } 1448 1449 /** 1450 * Returns an ordered range of all the file entries in the group starting at 1451 * the repository default parent folder that are stored within the Liferay 1452 * repository. This method is primarily used to search for recently modified 1453 * file entries. It can be limited to the file entries modified by a given 1454 * user. 1455 * 1456 * <p> 1457 * Useful when paginating results. Returns a maximum of <code>end - 1458 * start</code> instances. <code>start</code> and <code>end</code> are not 1459 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1460 * refers to the first result in the set. Setting both <code>start</code> 1461 * and <code>end</code> to {@link 1462 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1463 * result set. 1464 * </p> 1465 * 1466 * @param groupId the primary key of the group 1467 * @param userId the primary key of the user who created the file 1468 (optionally <code>0</code>) 1469 * @param start the lower bound of the range of results 1470 * @param end the upper bound of the range of results (not inclusive) 1471 * @return the range of matching file entries ordered by date modified 1472 * @throws PortalException if the group could not be found 1473 * @throws SystemException if a system exception occurred 1474 */ 1475 public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries( 1476 long groupId, long userId, int start, int end) 1477 throws RemoteException { 1478 try { 1479 java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue = 1480 DLAppServiceUtil.getGroupFileEntries(groupId, userId, start, end); 1481 1482 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue); 1483 } 1484 catch (Exception e) { 1485 _log.error(e, e); 1486 1487 throw new RemoteException(e.getMessage()); 1488 } 1489 } 1490 1491 /** 1492 * Returns an ordered range of all the file entries in the group that are 1493 * stored within the Liferay repository. This method is primarily used to 1494 * search for recently modified file entries. It can be limited to the file 1495 * entries modified by a given user. 1496 * 1497 * <p> 1498 * Useful when paginating results. Returns a maximum of <code>end - 1499 * start</code> instances. <code>start</code> and <code>end</code> are not 1500 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1501 * refers to the first result in the set. Setting both <code>start</code> 1502 * and <code>end</code> to {@link 1503 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1504 * result set. 1505 * </p> 1506 * 1507 * @param groupId the primary key of the group 1508 * @param userId the primary key of the user who created the file 1509 (optionally <code>0</code>) 1510 * @param start the lower bound of the range of results 1511 * @param end the upper bound of the range of results (not inclusive) 1512 * @param obc the comparator to order the file entries (optionally 1513 <code>null</code>) 1514 * @return the range of matching file entries ordered by comparator 1515 <code>obc</code> 1516 * @throws PortalException if the group could not be found 1517 * @throws SystemException if a system exception occurred 1518 */ 1519 public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries( 1520 long groupId, long userId, int start, int end, 1521 com.liferay.portal.kernel.util.OrderByComparator obc) 1522 throws RemoteException { 1523 try { 1524 java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue = 1525 DLAppServiceUtil.getGroupFileEntries(groupId, userId, start, 1526 end, obc); 1527 1528 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue); 1529 } 1530 catch (Exception e) { 1531 _log.error(e, e); 1532 1533 throw new RemoteException(e.getMessage()); 1534 } 1535 } 1536 1537 /** 1538 * Returns an ordered range of all the file entries in the group starting at 1539 * the root folder that are stored within the Liferay repository. This 1540 * method is primarily used to search for recently modified file entries. It 1541 * can be limited to the file entries modified by a given user. 1542 * 1543 * <p> 1544 * Useful when paginating results. Returns a maximum of <code>end - 1545 * start</code> instances. <code>start</code> and <code>end</code> are not 1546 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1547 * refers to the first result in the set. Setting both <code>start</code> 1548 * and <code>end</code> to {@link 1549 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1550 * result set. 1551 * </p> 1552 * 1553 * @param groupId the primary key of the group 1554 * @param userId the primary key of the user who created the file 1555 (optionally <code>0</code>) 1556 * @param rootFolderId the primary key of the root folder to begin the 1557 search 1558 * @param start the lower bound of the range of results 1559 * @param end the upper bound of the range of results (not inclusive) 1560 * @return the range of matching file entries ordered by date modified 1561 * @throws PortalException if the group could not be found 1562 * @throws SystemException if a system exception occurred 1563 */ 1564 public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries( 1565 long groupId, long userId, long rootFolderId, int start, int end) 1566 throws RemoteException { 1567 try { 1568 java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue = 1569 DLAppServiceUtil.getGroupFileEntries(groupId, userId, 1570 rootFolderId, start, end); 1571 1572 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue); 1573 } 1574 catch (Exception e) { 1575 _log.error(e, e); 1576 1577 throw new RemoteException(e.getMessage()); 1578 } 1579 } 1580 1581 /** 1582 * Returns an ordered range of all the file entries in the group starting at 1583 * the root folder that are stored within the Liferay repository. This 1584 * method is primarily used to search for recently modified file entries. It 1585 * can be limited to the file entries modified by a given user. 1586 * 1587 * <p> 1588 * Useful when paginating results. Returns a maximum of <code>end - 1589 * start</code> instances. <code>start</code> and <code>end</code> are not 1590 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1591 * refers to the first result in the set. Setting both <code>start</code> 1592 * and <code>end</code> to {@link 1593 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1594 * result set. 1595 * </p> 1596 * 1597 * @param groupId the primary key of the group 1598 * @param userId the primary key of the user who created the file 1599 (optionally <code>0</code>) 1600 * @param rootFolderId the primary key of the root folder to begin the 1601 search 1602 * @param start the lower bound of the range of results 1603 * @param end the upper bound of the range of results (not inclusive) 1604 * @param obc the comparator to order the file entries (optionally 1605 <code>null</code>) 1606 * @return the range of matching file entries ordered by comparator 1607 <code>obc</code> 1608 * @throws PortalException if the group could not be found 1609 * @throws SystemException if a system exception occurred 1610 */ 1611 public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries( 1612 long groupId, long userId, long rootFolderId, int start, int end, 1613 com.liferay.portal.kernel.util.OrderByComparator obc) 1614 throws RemoteException { 1615 try { 1616 java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue = 1617 DLAppServiceUtil.getGroupFileEntries(groupId, userId, 1618 rootFolderId, start, end, obc); 1619 1620 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue); 1621 } 1622 catch (Exception e) { 1623 _log.error(e, e); 1624 1625 throw new RemoteException(e.getMessage()); 1626 } 1627 } 1628 1629 public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries( 1630 long groupId, long userId, long rootFolderId, 1631 java.lang.String[] mimeTypes, int status, int start, int end, 1632 com.liferay.portal.kernel.util.OrderByComparator obc) 1633 throws RemoteException { 1634 try { 1635 java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue = 1636 DLAppServiceUtil.getGroupFileEntries(groupId, userId, 1637 rootFolderId, mimeTypes, status, start, end, obc); 1638 1639 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue); 1640 } 1641 catch (Exception e) { 1642 _log.error(e, e); 1643 1644 throw new RemoteException(e.getMessage()); 1645 } 1646 } 1647 1648 /** 1649 * Returns the number of file entries in a group starting at the repository 1650 * default parent folder that are stored within the Liferay repository. This 1651 * method is primarily used to search for recently modified file entries. It 1652 * can be limited to the file entries modified by a given user. 1653 * 1654 * @param groupId the primary key of the group 1655 * @param userId the primary key of the user who created the file 1656 (optionally <code>0</code>) 1657 * @return the number of matching file entries 1658 * @throws PortalException if the group could not be found 1659 * @throws SystemException if a system exception occurred 1660 */ 1661 public static int getGroupFileEntriesCount(long groupId, long userId) 1662 throws RemoteException { 1663 try { 1664 int returnValue = DLAppServiceUtil.getGroupFileEntriesCount(groupId, 1665 userId); 1666 1667 return returnValue; 1668 } 1669 catch (Exception e) { 1670 _log.error(e, e); 1671 1672 throw new RemoteException(e.getMessage()); 1673 } 1674 } 1675 1676 /** 1677 * Returns the number of file entries in a group starting at the root folder 1678 * that are stored within the Liferay repository. This method is primarily 1679 * used to search for recently modified file entries. It can be limited to 1680 * the file entries modified by a given user. 1681 * 1682 * @param groupId the primary key of the group 1683 * @param userId the primary key of the user who created the file 1684 (optionally <code>0</code>) 1685 * @param rootFolderId the primary key of the root folder to begin the 1686 search 1687 * @return the number of matching file entries 1688 * @throws PortalException if the group could not be found 1689 * @throws SystemException if a system exception occurred 1690 */ 1691 public static int getGroupFileEntriesCount(long groupId, long userId, 1692 long rootFolderId) throws RemoteException { 1693 try { 1694 int returnValue = DLAppServiceUtil.getGroupFileEntriesCount(groupId, 1695 userId, rootFolderId); 1696 1697 return returnValue; 1698 } 1699 catch (Exception e) { 1700 _log.error(e, e); 1701 1702 throw new RemoteException(e.getMessage()); 1703 } 1704 } 1705 1706 public static int getGroupFileEntriesCount(long groupId, long userId, 1707 long rootFolderId, java.lang.String[] mimeTypes, int status) 1708 throws RemoteException { 1709 try { 1710 int returnValue = DLAppServiceUtil.getGroupFileEntriesCount(groupId, 1711 userId, rootFolderId, mimeTypes, status); 1712 1713 return returnValue; 1714 } 1715 catch (Exception e) { 1716 _log.error(e, e); 1717 1718 throw new RemoteException(e.getMessage()); 1719 } 1720 } 1721 1722 /** 1723 * Returns all immediate subfolders of the parent folder that are used for 1724 * mounting third-party repositories. This method is only supported by the 1725 * Liferay repository. 1726 * 1727 * @param repositoryId the primary key of the folder's repository 1728 * @param parentFolderId the primary key of the folder's parent folder 1729 * @return the immediate subfolders of the parent folder that are used for 1730 mounting third-party repositories 1731 * @throws PortalException if the repository or parent folder could not be 1732 found 1733 * @throws SystemException if a system exception occurred 1734 */ 1735 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getMountFolders( 1736 long repositoryId, long parentFolderId) throws RemoteException { 1737 try { 1738 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1739 DLAppServiceUtil.getMountFolders(repositoryId, parentFolderId); 1740 1741 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1742 } 1743 catch (Exception e) { 1744 _log.error(e, e); 1745 1746 throw new RemoteException(e.getMessage()); 1747 } 1748 } 1749 1750 /** 1751 * Returns a name-ordered range of all the immediate subfolders of the 1752 * parent folder that are used for mounting third-party repositories. This 1753 * method is only supported by the Liferay repository. 1754 * 1755 * <p> 1756 * Useful when paginating results. Returns a maximum of <code>end - 1757 * start</code> instances. <code>start</code> and <code>end</code> are not 1758 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1759 * refers to the first result in the set. Setting both <code>start</code> 1760 * and <code>end</code> to {@link 1761 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1762 * result set. 1763 * </p> 1764 * 1765 * @param repositoryId the primary key of the repository 1766 * @param parentFolderId the primary key of the parent folder 1767 * @param start the lower bound of the range of results 1768 * @param end the upper bound of the range of results (not inclusive) 1769 * @return the name-ordered range of immediate subfolders of the parent 1770 folder that are used for mounting third-party repositories 1771 * @throws PortalException if the repository or parent folder could not be 1772 found 1773 * @throws SystemException if a system exception occurred 1774 */ 1775 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getMountFolders( 1776 long repositoryId, long parentFolderId, int start, int end) 1777 throws RemoteException { 1778 try { 1779 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1780 DLAppServiceUtil.getMountFolders(repositoryId, parentFolderId, 1781 start, end); 1782 1783 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1784 } 1785 catch (Exception e) { 1786 _log.error(e, e); 1787 1788 throw new RemoteException(e.getMessage()); 1789 } 1790 } 1791 1792 /** 1793 * Returns an ordered range of all the immediate subfolders of the parent 1794 * folder that are used for mounting third-party repositories. This method 1795 * is only supported by the Liferay repository. 1796 * 1797 * <p> 1798 * Useful when paginating results. Returns a maximum of <code>end - 1799 * start</code> instances. <code>start</code> and <code>end</code> are not 1800 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1801 * refers to the first result in the set. Setting both <code>start</code> 1802 * and <code>end</code> to {@link 1803 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1804 * result set. 1805 * </p> 1806 * 1807 * @param repositoryId the primary key of the folder's repository 1808 * @param parentFolderId the primary key of the folder's parent folder 1809 * @param start the lower bound of the range of results 1810 * @param end the upper bound of the range of results (not inclusive) 1811 * @param obc the comparator to order the folders (optionally 1812 <code>null</code>) 1813 * @return the range of immediate subfolders of the parent folder that are 1814 used for mounting third-party repositories ordered by comparator 1815 <code>obc</code> 1816 * @throws PortalException if the repository or parent folder could not be 1817 found 1818 * @throws SystemException if a system exception occurred 1819 */ 1820 public static com.liferay.portal.kernel.repository.model.FolderSoap[] getMountFolders( 1821 long repositoryId, long parentFolderId, int start, int end, 1822 com.liferay.portal.kernel.util.OrderByComparator obc) 1823 throws RemoteException { 1824 try { 1825 java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue = 1826 DLAppServiceUtil.getMountFolders(repositoryId, parentFolderId, 1827 start, end, obc); 1828 1829 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue); 1830 } 1831 catch (Exception e) { 1832 _log.error(e, e); 1833 1834 throw new RemoteException(e.getMessage()); 1835 } 1836 } 1837 1838 /** 1839 * Returns the number of immediate subfolders of the parent folder that are 1840 * used for mounting third-party repositories. This method is only supported 1841 * by the Liferay repository. 1842 * 1843 * @param repositoryId the primary key of the repository 1844 * @param parentFolderId the primary key of the parent folder 1845 * @return the number of folders of the parent folder that are used for 1846 mounting third-party repositories 1847 * @throws PortalException if the repository or parent folder could not be 1848 found 1849 * @throws SystemException if a system exception occurred 1850 */ 1851 public static int getMountFoldersCount(long repositoryId, 1852 long parentFolderId) throws RemoteException { 1853 try { 1854 int returnValue = DLAppServiceUtil.getMountFoldersCount(repositoryId, 1855 parentFolderId); 1856 1857 return returnValue; 1858 } 1859 catch (Exception e) { 1860 _log.error(e, e); 1861 1862 throw new RemoteException(e.getMessage()); 1863 } 1864 } 1865 1866 public static void getSubfolderIds(long repositoryId, Long[] folderIds, 1867 long folderId) throws RemoteException { 1868 try { 1869 DLAppServiceUtil.getSubfolderIds(repositoryId, 1870 ListUtil.toList(folderIds), folderId); 1871 } 1872 catch (Exception e) { 1873 _log.error(e, e); 1874 1875 throw new RemoteException(e.getMessage()); 1876 } 1877 } 1878 1879 /** 1880 * Returns all the descendant folders of the folder with the primary key. 1881 * 1882 * @param repositoryId the primary key of the repository 1883 * @param folderId the primary key of the folder 1884 * @return the descendant folders of the folder with the primary key 1885 * @throws PortalException if the repository or parent folder could not be 1886 found 1887 * @throws SystemException if a system exception occurred 1888 */ 1889 public static java.lang.Long[] getSubfolderIds(long repositoryId, 1890 long folderId) throws RemoteException { 1891 try { 1892 java.util.List<java.lang.Long> returnValue = DLAppServiceUtil.getSubfolderIds(repositoryId, 1893 folderId); 1894 1895 return returnValue.toArray(new java.lang.Long[returnValue.size()]); 1896 } 1897 catch (Exception e) { 1898 _log.error(e, e); 1899 1900 throw new RemoteException(e.getMessage()); 1901 } 1902 } 1903 1904 /** 1905 * Returns descendant folders of the folder with the primary key, optionally 1906 * limiting to one level deep. 1907 * 1908 * @param repositoryId the primary key of the repository 1909 * @param folderId the primary key of the folder 1910 * @param recurse whether to recurse through each subfolder 1911 * @return the descendant folders of the folder with the primary key 1912 * @throws PortalException if the repository or parent folder could not be 1913 found 1914 * @throws SystemException if a system exception occurred 1915 */ 1916 public static java.lang.Long[] getSubfolderIds(long repositoryId, 1917 long folderId, boolean recurse) throws RemoteException { 1918 try { 1919 java.util.List<java.lang.Long> returnValue = DLAppServiceUtil.getSubfolderIds(repositoryId, 1920 folderId, recurse); 1921 1922 return returnValue.toArray(new java.lang.Long[returnValue.size()]); 1923 } 1924 catch (Exception e) { 1925 _log.error(e, e); 1926 1927 throw new RemoteException(e.getMessage()); 1928 } 1929 } 1930 1931 /** 1932 * Returns all the temporary file entry names. 1933 * 1934 * @param groupId the primary key of the group 1935 * @param folderId the primary key of the folder where the file entry will 1936 eventually reside 1937 * @param tempFolderName the temporary folder's name 1938 * @return the temporary file entry names 1939 * @throws PortalException if the folder was invalid 1940 * @throws SystemException if a system exception occurred 1941 * @see #addTempFileEntry(long, long, String, String, File, String) 1942 * @see com.liferay.portal.kernel.util.TempFileUtil 1943 */ 1944 public static java.lang.String[] getTempFileEntryNames(long groupId, 1945 long folderId, java.lang.String tempFolderName) 1946 throws RemoteException { 1947 try { 1948 java.lang.String[] returnValue = DLAppServiceUtil.getTempFileEntryNames(groupId, 1949 folderId, tempFolderName); 1950 1951 return returnValue; 1952 } 1953 catch (Exception e) { 1954 _log.error(e, e); 1955 1956 throw new RemoteException(e.getMessage()); 1957 } 1958 } 1959 1960 /** 1961 * Moves the file entry to the new folder. 1962 * 1963 * @param fileEntryId the primary key of the file entry 1964 * @param newFolderId the primary key of the new folder 1965 * @param serviceContext the service context to be applied 1966 * @return the file entry 1967 * @throws PortalException if the file entry or the new folder could not be 1968 found 1969 * @throws SystemException if a system exception occurred 1970 */ 1971 public static com.liferay.portal.kernel.repository.model.FileEntrySoap moveFileEntry( 1972 long fileEntryId, long newFolderId, 1973 com.liferay.portal.service.ServiceContext serviceContext) 1974 throws RemoteException { 1975 try { 1976 com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.moveFileEntry(fileEntryId, 1977 newFolderId, serviceContext); 1978 1979 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue); 1980 } 1981 catch (Exception e) { 1982 _log.error(e, e); 1983 1984 throw new RemoteException(e.getMessage()); 1985 } 1986 } 1987 1988 /** 1989 * Moves the file entry from a trashed folder to the new folder. 1990 * 1991 * @param fileEntryId the primary key of the file entry 1992 * @param newFolderId the primary key of the new folder 1993 * @param serviceContext the service context to be applied 1994 * @return the file entry 1995 * @throws PortalException if the file entry or the new folder could not be 1996 found 1997 * @throws SystemException if a system exception occurred 1998 */ 1999 public static com.liferay.portal.kernel.repository.model.FileEntrySoap moveFileEntryFromTrash( 2000 long fileEntryId, long newFolderId, 2001 com.liferay.portal.service.ServiceContext serviceContext) 2002 throws RemoteException { 2003 try { 2004 com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.moveFileEntryFromTrash(fileEntryId, 2005 newFolderId, serviceContext); 2006 2007 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue); 2008 } 2009 catch (Exception e) { 2010 _log.error(e, e); 2011 2012 throw new RemoteException(e.getMessage()); 2013 } 2014 } 2015 2016 /** 2017 * Moves the file entry with the primary key to the trash portlet. 2018 * 2019 * @param fileEntryId the primary key of the file entry 2020 * @return the file entry 2021 * @throws PortalException if the file entry could not be found 2022 * @throws SystemException if a system exception occurred 2023 */ 2024 public static com.liferay.portal.kernel.repository.model.FileEntrySoap moveFileEntryToTrash( 2025 long fileEntryId) throws RemoteException { 2026 try { 2027 com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.moveFileEntryToTrash(fileEntryId); 2028 2029 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue); 2030 } 2031 catch (Exception e) { 2032 _log.error(e, e); 2033 2034 throw new RemoteException(e.getMessage()); 2035 } 2036 } 2037 2038 /** 2039 * Moves the file shortcut from a trashed folder to the new folder. 2040 * 2041 * @param fileShortcutId the primary key of the file shortcut 2042 * @param newFolderId the primary key of the new folder 2043 * @param serviceContext the service context to be applied 2044 * @return the file shortcut 2045 * @throws PortalException if the file entry or the new folder could not be 2046 found 2047 * @throws SystemException if a system exception occurred 2048 */ 2049 public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap moveFileShortcutFromTrash( 2050 long fileShortcutId, long newFolderId, 2051 com.liferay.portal.service.ServiceContext serviceContext) 2052 throws RemoteException { 2053 try { 2054 com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue = 2055 DLAppServiceUtil.moveFileShortcutFromTrash(fileShortcutId, 2056 newFolderId, serviceContext); 2057 2058 return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue); 2059 } 2060 catch (Exception e) { 2061 _log.error(e, e); 2062 2063 throw new RemoteException(e.getMessage()); 2064 } 2065 } 2066 2067 /** 2068 * Moves the file shortcut with the primary key to the trash portlet. 2069 * 2070 * @param fileShortcutId the primary key of the file shortcut 2071 * @return the file shortcut 2072 * @throws PortalException if the file shortcut could not be found 2073 * @throws SystemException if a system exception occurred 2074 */ 2075 public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap moveFileShortcutToTrash( 2076 long fileShortcutId) throws RemoteException { 2077 try { 2078 com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue = 2079 DLAppServiceUtil.moveFileShortcutToTrash(fileShortcutId); 2080 2081 return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue); 2082 } 2083 catch (Exception e) { 2084 _log.error(e, e); 2085 2086 throw new RemoteException(e.getMessage()); 2087 } 2088 } 2089 2090 /** 2091 * Moves the folder to the new parent folder with the primary key. 2092 * 2093 * @param folderId the primary key of the folder 2094 * @param parentFolderId the primary key of the new parent folder 2095 * @param serviceContext the service context to be applied 2096 * @return the file entry 2097 * @throws PortalException if the folder could not be found 2098 * @throws SystemException if a system exception occurred 2099 */ 2100 public static com.liferay.portal.kernel.repository.model.FolderSoap moveFolder( 2101 long folderId, long parentFolderId, 2102 com.liferay.portal.service.ServiceContext serviceContext) 2103 throws RemoteException { 2104 try { 2105 com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.moveFolder(folderId, 2106 parentFolderId, serviceContext); 2107 2108 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue); 2109 } 2110 catch (Exception e) { 2111 _log.error(e, e); 2112 2113 throw new RemoteException(e.getMessage()); 2114 } 2115 } 2116 2117 /** 2118 * Moves the folder with the primary key from the trash portlet to the new 2119 * parent folder with the primary key. 2120 * 2121 * @param folderId the primary key of the folder 2122 * @param parentFolderId the primary key of the new parent folder 2123 * @param serviceContext the service context to be applied 2124 * @return the file entry 2125 * @throws PortalException if the folder could not be found 2126 * @throws SystemException if a system exception occurred 2127 */ 2128 public static com.liferay.portal.kernel.repository.model.FolderSoap moveFolderFromTrash( 2129 long folderId, long parentFolderId, 2130 com.liferay.portal.service.ServiceContext serviceContext) 2131 throws RemoteException { 2132 try { 2133 com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.moveFolderFromTrash(folderId, 2134 parentFolderId, serviceContext); 2135 2136 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue); 2137 } 2138 catch (Exception e) { 2139 _log.error(e, e); 2140 2141 throw new RemoteException(e.getMessage()); 2142 } 2143 } 2144 2145 /** 2146 * Moves the folder with the primary key to the trash portlet. 2147 * 2148 * @param folderId the primary key of the folder 2149 * @return the file entry 2150 * @throws PortalException if the folder could not be found 2151 * @throws SystemException if a system exception occurred 2152 */ 2153 public static com.liferay.portal.kernel.repository.model.FolderSoap moveFolderToTrash( 2154 long folderId) throws RemoteException { 2155 try { 2156 com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.moveFolderToTrash(folderId); 2157 2158 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue); 2159 } 2160 catch (Exception e) { 2161 _log.error(e, e); 2162 2163 throw new RemoteException(e.getMessage()); 2164 } 2165 } 2166 2167 /** 2168 * Restores the file entry with the primary key from the trash portlet. 2169 * 2170 * @param fileEntryId the primary key of the file entry 2171 * @throws PortalException if the file entry could not be found 2172 * @throws SystemException if a system exception occurred 2173 */ 2174 public static void restoreFileEntryFromTrash(long fileEntryId) 2175 throws RemoteException { 2176 try { 2177 DLAppServiceUtil.restoreFileEntryFromTrash(fileEntryId); 2178 } 2179 catch (Exception e) { 2180 _log.error(e, e); 2181 2182 throw new RemoteException(e.getMessage()); 2183 } 2184 } 2185 2186 /** 2187 * Restores the file shortcut with the primary key from the trash portlet. 2188 * 2189 * @param fileShortcutId the primary key of the file shortcut 2190 * @throws PortalException if the file shortcut could not be found 2191 * @throws SystemException if a system exception occurred 2192 */ 2193 public static void restoreFileShortcutFromTrash(long fileShortcutId) 2194 throws RemoteException { 2195 try { 2196 DLAppServiceUtil.restoreFileShortcutFromTrash(fileShortcutId); 2197 } 2198 catch (Exception e) { 2199 _log.error(e, e); 2200 2201 throw new RemoteException(e.getMessage()); 2202 } 2203 } 2204 2205 /** 2206 * Restores the folder with the primary key from the trash portlet. 2207 * 2208 * @param folderId the primary key of the folder 2209 * @throws PortalException if the folder could not be found 2210 * @throws SystemException if a system exception occurred 2211 */ 2212 public static void restoreFolderFromTrash(long folderId) 2213 throws RemoteException { 2214 try { 2215 DLAppServiceUtil.restoreFolderFromTrash(folderId); 2216 } 2217 catch (Exception e) { 2218 _log.error(e, e); 2219 2220 throw new RemoteException(e.getMessage()); 2221 } 2222 } 2223 2224 /** 2225 * Reverts the file entry to a previous version. A new version will be 2226 * created based on the previous version and metadata. 2227 * 2228 * @param fileEntryId the primary key of the file entry 2229 * @param version the version to revert back to 2230 * @param serviceContext the service context to be applied 2231 * @throws PortalException if the file entry or version could not be found 2232 * @throws SystemException if a system exception occurred 2233 */ 2234 public static void revertFileEntry(long fileEntryId, 2235 java.lang.String version, 2236 com.liferay.portal.service.ServiceContext serviceContext) 2237 throws RemoteException { 2238 try { 2239 DLAppServiceUtil.revertFileEntry(fileEntryId, version, 2240 serviceContext); 2241 } 2242 catch (Exception e) { 2243 _log.error(e, e); 2244 2245 throw new RemoteException(e.getMessage()); 2246 } 2247 } 2248 2249 /** 2250 * Subscribe the user to changes in documents of the file entry type. This 2251 * method is only supported by the Liferay repository. 2252 * 2253 * @param groupId the primary key of the file entry type's group 2254 * @param fileEntryTypeId the primary key of the file entry type 2255 * @throws PortalException if the user or group could not be found, or if 2256 subscribing was not permissible 2257 * @throws SystemException if a system exception occurred 2258 */ 2259 public static void subscribeFileEntryType(long groupId, long fileEntryTypeId) 2260 throws RemoteException { 2261 try { 2262 DLAppServiceUtil.subscribeFileEntryType(groupId, fileEntryTypeId); 2263 } 2264 catch (Exception e) { 2265 _log.error(e, e); 2266 2267 throw new RemoteException(e.getMessage()); 2268 } 2269 } 2270 2271 /** 2272 * Subscribe the user to document changes in the folder. This method is only 2273 * supported by the Liferay repository. 2274 * 2275 * @param groupId the primary key of the folder's group 2276 * @param folderId the primary key of the folder 2277 * @throws PortalException if the user or group could not be found, or if 2278 subscribing was not permissible 2279 * @throws SystemException if a system exception occurred 2280 */ 2281 public static void subscribeFolder(long groupId, long folderId) 2282 throws RemoteException { 2283 try { 2284 DLAppServiceUtil.subscribeFolder(groupId, folderId); 2285 } 2286 catch (Exception e) { 2287 _log.error(e, e); 2288 2289 throw new RemoteException(e.getMessage()); 2290 } 2291 } 2292 2293 /** 2294 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 2295 boolean, String, ServiceContext)}. 2296 */ 2297 public static void unlockFileEntry(long fileEntryId) 2298 throws RemoteException { 2299 try { 2300 DLAppServiceUtil.unlockFileEntry(fileEntryId); 2301 } 2302 catch (Exception e) { 2303 _log.error(e, e); 2304 2305 throw new RemoteException(e.getMessage()); 2306 } 2307 } 2308 2309 /** 2310 * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long, 2311 String)}. 2312 */ 2313 public static void unlockFileEntry(long fileEntryId, 2314 java.lang.String lockUuid) throws RemoteException { 2315 try { 2316 DLAppServiceUtil.unlockFileEntry(fileEntryId, lockUuid); 2317 } 2318 catch (Exception e) { 2319 _log.error(e, e); 2320 2321 throw new RemoteException(e.getMessage()); 2322 } 2323 } 2324 2325 /** 2326 * Unlocks the folder. This method is primarily used by WebDAV. 2327 * 2328 * @param repositoryId the primary key of the repository 2329 * @param folderId the primary key of the folder 2330 * @param lockUuid the lock's UUID 2331 * @throws PortalException if the repository or folder could not be found 2332 * @throws SystemException if a system exception occurred 2333 */ 2334 public static void unlockFolder(long repositoryId, long folderId, 2335 java.lang.String lockUuid) throws RemoteException { 2336 try { 2337 DLAppServiceUtil.unlockFolder(repositoryId, folderId, lockUuid); 2338 } 2339 catch (Exception e) { 2340 _log.error(e, e); 2341 2342 throw new RemoteException(e.getMessage()); 2343 } 2344 } 2345 2346 /** 2347 * Unlocks the folder. This method is primarily used by WebDAV. 2348 * 2349 * @param repositoryId the primary key of the repository 2350 * @param parentFolderId the primary key of the parent folder 2351 * @param name the folder's name 2352 * @param lockUuid the lock's UUID 2353 * @throws PortalException if the repository or folder could not be found 2354 * @throws SystemException if a system exception occurred 2355 */ 2356 public static void unlockFolder(long repositoryId, long parentFolderId, 2357 java.lang.String name, java.lang.String lockUuid) 2358 throws RemoteException { 2359 try { 2360 DLAppServiceUtil.unlockFolder(repositoryId, parentFolderId, name, 2361 lockUuid); 2362 } 2363 catch (Exception e) { 2364 _log.error(e, e); 2365 2366 throw new RemoteException(e.getMessage()); 2367 } 2368 } 2369 2370 /** 2371 * Unsubscribe the user from changes in documents of the file entry type. 2372 * This method is only supported by the Liferay repository. 2373 * 2374 * @param groupId the primary key of the file entry type's group 2375 * @param fileEntryTypeId the primary key of the file entry type 2376 * @throws PortalException if the user or group could not be found, or if 2377 unsubscribing was not permissible 2378 * @throws SystemException if a system exception occurred 2379 */ 2380 public static void unsubscribeFileEntryType(long groupId, 2381 long fileEntryTypeId) throws RemoteException { 2382 try { 2383 DLAppServiceUtil.unsubscribeFileEntryType(groupId, fileEntryTypeId); 2384 } 2385 catch (Exception e) { 2386 _log.error(e, e); 2387 2388 throw new RemoteException(e.getMessage()); 2389 } 2390 } 2391 2392 /** 2393 * Unsubscribe the user from document changes in the folder. This method is 2394 * only supported by the Liferay repository. 2395 * 2396 * @param groupId the primary key of the folder's group 2397 * @param folderId the primary key of the folder 2398 * @throws PortalException if the user or group could not be found, or if 2399 unsubscribing was not permissible 2400 * @throws SystemException if a system exception occurred 2401 */ 2402 public static void unsubscribeFolder(long groupId, long folderId) 2403 throws RemoteException { 2404 try { 2405 DLAppServiceUtil.unsubscribeFolder(groupId, folderId); 2406 } 2407 catch (Exception e) { 2408 _log.error(e, e); 2409 2410 throw new RemoteException(e.getMessage()); 2411 } 2412 } 2413 2414 /** 2415 * Updates a file entry and associated metadata based on a byte array 2416 * object. If the file data is <code>null</code>, then only the associated 2417 * metadata (i.e., <code>title</code>, <code>description</code>, and 2418 * parameters in the <code>serviceContext</code>) will be updated. 2419 * 2420 * <p> 2421 * This method takes two file names, the <code>sourceFileName</code> and the 2422 * <code>title</code>. The <code>sourceFileName</code> corresponds to the 2423 * name of the actual file being uploaded. The <code>title</code> 2424 * corresponds to a name the client wishes to assign this file after it has 2425 * been uploaded to the portal. 2426 * </p> 2427 * 2428 * @param fileEntryId the primary key of the file entry 2429 * @param sourceFileName the original file's name (optionally 2430 <code>null</code>) 2431 * @param mimeType the file's MIME type (optionally <code>null</code>) 2432 * @param title the new name to be assigned to the file (optionally <code> 2433 <code>null</code></code>) 2434 * @param description the file's new description 2435 * @param changeLog the file's version change log (optionally 2436 <code>null</code>) 2437 * @param majorVersion whether the new file version is a major version 2438 * @param bytes the file's data (optionally <code>null</code>) 2439 * @param serviceContext the service context to be applied. Can set the 2440 asset category IDs, asset tag names, and expando bridge 2441 attributes for the file entry. In a Liferay repository, it may 2442 include: <ul> <li> fileEntryTypeId - ID for a custom file entry 2443 type </li> <li> fieldsMap - mapping for fields associated with a 2444 custom file entry type </li> </ul> 2445 * @return the file entry 2446 * @throws PortalException if the file entry could not be found 2447 * @throws SystemException if a system exception occurred 2448 */ 2449 public static com.liferay.portal.kernel.repository.model.FileEntrySoap updateFileEntry( 2450 long fileEntryId, java.lang.String sourceFileName, 2451 java.lang.String mimeType, java.lang.String title, 2452 java.lang.String description, java.lang.String changeLog, 2453 boolean majorVersion, byte[] bytes, 2454 com.liferay.portal.service.ServiceContext serviceContext) 2455 throws RemoteException { 2456 try { 2457 com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.updateFileEntry(fileEntryId, 2458 sourceFileName, mimeType, title, description, changeLog, 2459 majorVersion, bytes, serviceContext); 2460 2461 return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue); 2462 } 2463 catch (Exception e) { 2464 _log.error(e, e); 2465 2466 throw new RemoteException(e.getMessage()); 2467 } 2468 } 2469 2470 /** 2471 * Updates a file shortcut to the existing file entry. This method is only 2472 * supported by the Liferay repository. 2473 * 2474 * @param fileShortcutId the primary key of the file shortcut 2475 * @param folderId the primary key of the file shortcut's parent folder 2476 * @param toFileEntryId the primary key of the file shortcut's file entry 2477 * @param serviceContext the service context to be applied. Can set the 2478 asset category IDs, asset tag names, and expando bridge 2479 attributes for the file entry. 2480 * @return the file shortcut 2481 * @throws PortalException if the file shortcut, folder, or file entry could 2482 not be found 2483 * @throws SystemException if a system exception occurred 2484 */ 2485 public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap updateFileShortcut( 2486 long fileShortcutId, long folderId, long toFileEntryId, 2487 com.liferay.portal.service.ServiceContext serviceContext) 2488 throws RemoteException { 2489 try { 2490 com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue = 2491 DLAppServiceUtil.updateFileShortcut(fileShortcutId, folderId, 2492 toFileEntryId, serviceContext); 2493 2494 return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue); 2495 } 2496 catch (Exception e) { 2497 _log.error(e, e); 2498 2499 throw new RemoteException(e.getMessage()); 2500 } 2501 } 2502 2503 /** 2504 * Updates the folder. 2505 * 2506 * @param folderId the primary key of the folder 2507 * @param name the folder's new name 2508 * @param description the folder's new description 2509 * @param serviceContext the service context to be applied. In a Liferay 2510 repository, it may include: <ul> <li> defaultFileEntryTypeId - 2511 the file entry type to default all Liferay file entries to </li> 2512 <li> dlFileEntryTypesSearchContainerPrimaryKeys - a 2513 comma-delimited list of file entry type primary keys allowed in 2514 the given folder and all descendants </li> <li> 2515 overrideFileEntryTypes - boolean specifying whether to override 2516 ancestral folder's restriction of file entry types allowed </li> 2517 <li> workflowDefinitionXYZ - the workflow definition name 2518 specified per file entry type. The parameter name must be the 2519 string <code>workflowDefinition</code> appended by the <code> 2520 fileEntryTypeId</code> (optionally <code>0</code>). </li> </ul> 2521 * @return the folder 2522 * @throws PortalException if the current or new parent folder could not be 2523 found or if the new parent folder's information was invalid 2524 * @throws SystemException if a system exception occurred 2525 */ 2526 public static com.liferay.portal.kernel.repository.model.FolderSoap updateFolder( 2527 long folderId, java.lang.String name, java.lang.String description, 2528 com.liferay.portal.service.ServiceContext serviceContext) 2529 throws RemoteException { 2530 try { 2531 com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.updateFolder(folderId, 2532 name, description, serviceContext); 2533 2534 return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue); 2535 } 2536 catch (Exception e) { 2537 _log.error(e, e); 2538 2539 throw new RemoteException(e.getMessage()); 2540 } 2541 } 2542 2543 /** 2544 * Returns <code>true</code> if the file entry is checked out. This method 2545 * is primarily used by WebDAV. 2546 * 2547 * @param repositoryId the primary key for the repository 2548 * @param fileEntryId the primary key for the file entry 2549 * @param lockUuid the lock's UUID 2550 * @return <code>true</code> if the file entry is checked out; 2551 <code>false</code> otherwise 2552 * @throws PortalException if the file entry could not be found 2553 * @throws SystemException if a system exception occurred 2554 */ 2555 public static boolean verifyFileEntryCheckOut(long repositoryId, 2556 long fileEntryId, java.lang.String lockUuid) throws RemoteException { 2557 try { 2558 boolean returnValue = DLAppServiceUtil.verifyFileEntryCheckOut(repositoryId, 2559 fileEntryId, lockUuid); 2560 2561 return returnValue; 2562 } 2563 catch (Exception e) { 2564 _log.error(e, e); 2565 2566 throw new RemoteException(e.getMessage()); 2567 } 2568 } 2569 2570 public static boolean verifyFileEntryLock(long repositoryId, 2571 long fileEntryId, java.lang.String lockUuid) throws RemoteException { 2572 try { 2573 boolean returnValue = DLAppServiceUtil.verifyFileEntryLock(repositoryId, 2574 fileEntryId, lockUuid); 2575 2576 return returnValue; 2577 } 2578 catch (Exception e) { 2579 _log.error(e, e); 2580 2581 throw new RemoteException(e.getMessage()); 2582 } 2583 } 2584 2585 /** 2586 * Returns <code>true</code> if the inheritable lock exists. This method is 2587 * primarily used by WebDAV. 2588 * 2589 * @param repositoryId the primary key for the repository 2590 * @param folderId the primary key for the folder 2591 * @param lockUuid the lock's UUID 2592 * @return <code>true</code> if the inheritable lock exists; 2593 <code>false</code> otherwise 2594 * @throws PortalException if the folder could not be found 2595 * @throws SystemException if a system exception occurred 2596 */ 2597 public static boolean verifyInheritableLock(long repositoryId, 2598 long folderId, java.lang.String lockUuid) throws RemoteException { 2599 try { 2600 boolean returnValue = DLAppServiceUtil.verifyInheritableLock(repositoryId, 2601 folderId, lockUuid); 2602 2603 return returnValue; 2604 } 2605 catch (Exception e) { 2606 _log.error(e, e); 2607 2608 throw new RemoteException(e.getMessage()); 2609 } 2610 } 2611 2612 private static Log _log = LogFactoryUtil.getLog(DLAppServiceSoap.class); 2613 }