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