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