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