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