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