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    }