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