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