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.portlet.documentlibrary.model.DLFileShortcut 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 range of all the file entries with the file entry type in the
604            * 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 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 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 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.portlet.documentlibrary.model.DLFileShortcut 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 range of all the immediate subfolders of the parent folder,
952            * optionally including mount folders for third-party repositories.
953            *
954            * <p>
955            * Useful when paginating results. Returns a maximum of <code>end -
956            * start</code> instances. <code>start</code> and <code>end</code> are not
957            * primary keys, they are indexes in the result set. Thus, <code>0</code>
958            * refers to the first result in the set. Setting both <code>start</code>
959            * and <code>end</code> to {@link
960            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
961            * result set.
962            * </p>
963            *
964            * @param repositoryId the primary key of the folder's repository
965            * @param parentFolderId the primary key of the folder's parent folder
966            * @param includeMountFolders whether to include mount folders for
967            third-party repositories
968            * @param start the lower bound of the range of results
969            * @param end the upper bound of the range of results (not inclusive)
970            * @return the range of immediate subfolders of the parent folder
971            * @throws PortalException if the parent folder could not be found
972            */
973            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
974                    long repositoryId, long parentFolderId, boolean includeMountFolders,
975                    int start, int end)
976                    throws com.liferay.portal.kernel.exception.PortalException {
977                    return getService()
978                                       .getFolders(repositoryId, parentFolderId,
979                            includeMountFolders, start, end);
980            }
981    
982            /**
983            * Returns an ordered range of all the immediate subfolders of the parent
984            * folder.
985            *
986            * <p>
987            * Useful when paginating results. Returns a maximum of <code>end -
988            * start</code> instances. <code>start</code> and <code>end</code> are not
989            * primary keys, they are indexes in the result set. Thus, <code>0</code>
990            * refers to the first result in the set. Setting both <code>start</code>
991            * and <code>end</code> to {@link
992            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
993            * result set.
994            * </p>
995            *
996            * @param repositoryId the primary key of the folder's repository
997            * @param parentFolderId the primary key of the folder's parent folder
998            * @param includeMountFolders whether to include mount folders for
999            third-party repositories
1000            * @param start the lower bound of the range of results
1001            * @param end the upper bound of the range of results (not inclusive)
1002            * @param obc the comparator to order the folders (optionally
1003            <code>null</code>)
1004            * @return the range of immediate subfolders of the parent folder ordered by
1005            comparator <code>obc</code>
1006            * @throws PortalException if the parent folder could not be found
1007            */
1008            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1009                    long repositoryId, long parentFolderId, boolean includeMountFolders,
1010                    int start, int end,
1011                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1012                    throws com.liferay.portal.kernel.exception.PortalException {
1013                    return getService()
1014                                       .getFolders(repositoryId, parentFolderId,
1015                            includeMountFolders, start, end, obc);
1016            }
1017    
1018            /**
1019            * Returns a range of all the immediate subfolders of the parent folder.
1020            *
1021            * <p>
1022            * Useful when paginating results. Returns a maximum of <code>end -
1023            * start</code> instances. <code>start</code> and <code>end</code> are not
1024            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1025            * refers to the first result in the set. Setting both <code>start</code>
1026            * and <code>end</code> to {@link
1027            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1028            * result set.
1029            * </p>
1030            *
1031            * @param repositoryId the primary key of the folder's repository
1032            * @param parentFolderId the primary key of the folder's parent folder
1033            * @param start the lower bound of the range of results
1034            * @param end the upper bound of the range of results (not inclusive)
1035            * @return the range of immediate subfolders of the parent folder
1036            * @throws PortalException if the parent folder could not be found
1037            */
1038            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1039                    long repositoryId, long parentFolderId, int start, int end)
1040                    throws com.liferay.portal.kernel.exception.PortalException {
1041                    return getService().getFolders(repositoryId, parentFolderId, start, end);
1042            }
1043    
1044            /**
1045            * Returns an ordered range of all the immediate subfolders of the parent
1046            * folder.
1047            *
1048            * <p>
1049            * Useful when paginating results. Returns a maximum of <code>end -
1050            * start</code> instances. <code>start</code> and <code>end</code> are not
1051            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1052            * refers to the first result in the set. Setting both <code>start</code>
1053            * and <code>end</code> to {@link
1054            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1055            * result set.
1056            * </p>
1057            *
1058            * @param repositoryId the primary key of the folder's repository
1059            * @param parentFolderId the primary key of the folder's parent folder
1060            * @param start the lower bound of the range of results
1061            * @param end the upper bound of the range of results (not inclusive)
1062            * @param obc the comparator to order the folders (optionally
1063            <code>null</code>)
1064            * @return the range of immediate subfolders of the parent folder ordered by
1065            comparator <code>obc</code>
1066            * @throws PortalException if the parent folder could not be found
1067            */
1068            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1069                    long repositoryId, long parentFolderId, int start, int end,
1070                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1071                    throws com.liferay.portal.kernel.exception.PortalException {
1072                    return getService()
1073                                       .getFolders(repositoryId, parentFolderId, start, end, obc);
1074            }
1075    
1076            /**
1077            * Returns an ordered range of all the immediate subfolders of the parent
1078            * folder.
1079            *
1080            * <p>
1081            * Useful when paginating results. Returns a maximum of <code>end -
1082            * start</code> instances. <code>start</code> and <code>end</code> are not
1083            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1084            * refers to the first result in the set. Setting both <code>start</code>
1085            * and <code>end</code> to {@link
1086            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1087            * result set.
1088            * </p>
1089            *
1090            * @param repositoryId the primary key of the folder's repository
1091            * @param parentFolderId the primary key of the folder's parent folder
1092            * @param status the workflow status
1093            * @param includeMountFolders whether to include mount folders for
1094            third-party repositories
1095            * @param start the lower bound of the range of results
1096            * @param end the upper bound of the range of results (not inclusive)
1097            * @param obc the comparator to order the folders (optionally
1098            <code>null</code>)
1099            * @return the range of immediate subfolders of the parent folder ordered by
1100            comparator <code>obc</code>
1101            * @throws PortalException if the parent folder could not be found
1102            */
1103            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1104                    long repositoryId, long parentFolderId, int status,
1105                    boolean includeMountFolders, int start, int end,
1106                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1107                    throws com.liferay.portal.kernel.exception.PortalException {
1108                    return getService()
1109                                       .getFolders(repositoryId, parentFolderId, status,
1110                            includeMountFolders, start, end, obc);
1111            }
1112    
1113            /**
1114            * Returns a range of all the immediate subfolders, file entries, and file
1115            * shortcuts in the parent folder.
1116            *
1117            * <p>
1118            * Useful when paginating results. Returns a maximum of <code>end -
1119            * start</code> instances. <code>start</code> and <code>end</code> are not
1120            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1121            * refers to the first result in the set. Setting both <code>start</code>
1122            * and <code>end</code> to {@link
1123            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1124            * result set.
1125            * </p>
1126            *
1127            * @param repositoryId the primary key of the repository
1128            * @param folderId the primary key of the parent folder
1129            * @param status the workflow status
1130            * @param includeMountFolders whether to include mount folders for
1131            third-party repositories
1132            * @param start the lower bound of the range of results
1133            * @param end the upper bound of the range of results (not inclusive)
1134            * @return the range of immediate subfolders, file entries, and file
1135            shortcuts in the parent folder ordered by comparator
1136            <code>obc</code>
1137            * @throws PortalException if the parent folder could not be found
1138            */
1139            public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts(
1140                    long repositoryId, long folderId, int status,
1141                    boolean includeMountFolders, int start, int end)
1142                    throws com.liferay.portal.kernel.exception.PortalException {
1143                    return getService()
1144                                       .getFoldersAndFileEntriesAndFileShortcuts(repositoryId,
1145                            folderId, status, includeMountFolders, start, end);
1146            }
1147    
1148            /**
1149            * Returns an ordered range of all the immediate subfolders, file entries,
1150            * and file shortcuts in the parent folder.
1151            *
1152            * <p>
1153            * Useful when paginating results. Returns a maximum of <code>end -
1154            * start</code> instances. <code>start</code> and <code>end</code> are not
1155            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1156            * refers to the first result in the set. Setting both <code>start</code>
1157            * and <code>end</code> to {@link
1158            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1159            * result set.
1160            * </p>
1161            *
1162            * @param repositoryId the primary key of the repository
1163            * @param folderId the primary key of the parent folder
1164            * @param status the workflow status
1165            * @param includeMountFolders whether to include mount folders for
1166            third-party repositories
1167            * @param start the lower bound of the range of results
1168            * @param end the upper bound of the range of results (not inclusive)
1169            * @param obc the comparator to order the results (optionally
1170            <code>null</code>)
1171            * @return the range of immediate subfolders, file entries, and file
1172            shortcuts in the parent folder ordered by comparator
1173            <code>obc</code>
1174            * @throws PortalException if the parent folder could not be found
1175            */
1176            public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts(
1177                    long repositoryId, long folderId, int status,
1178                    boolean includeMountFolders, int start, int end,
1179                    com.liferay.portal.kernel.util.OrderByComparator<?> obc)
1180                    throws com.liferay.portal.kernel.exception.PortalException {
1181                    return getService()
1182                                       .getFoldersAndFileEntriesAndFileShortcuts(repositoryId,
1183                            folderId, status, includeMountFolders, start, end, obc);
1184            }
1185    
1186            public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts(
1187                    long repositoryId, long folderId, int status,
1188                    java.lang.String[] mimeTypes, boolean includeMountFolders, int start,
1189                    int end, com.liferay.portal.kernel.util.OrderByComparator<?> obc)
1190                    throws com.liferay.portal.kernel.exception.PortalException {
1191                    return getService()
1192                                       .getFoldersAndFileEntriesAndFileShortcuts(repositoryId,
1193                            folderId, status, mimeTypes, includeMountFolders, start, end, obc);
1194            }
1195    
1196            /**
1197            * Returns the number of immediate subfolders, file entries, and file
1198            * shortcuts in the parent folder.
1199            *
1200            * @param repositoryId the primary key of the repository
1201            * @param folderId the primary key of the parent folder
1202            * @param status the workflow status
1203            * @param includeMountFolders whether to include mount folders for
1204            third-party repositories
1205            * @return the number of immediate subfolders, file entries, and file
1206            shortcuts in the parent folder
1207            * @throws PortalException if the folder could not be found
1208            */
1209            public static int getFoldersAndFileEntriesAndFileShortcutsCount(
1210                    long repositoryId, long folderId, int status,
1211                    boolean includeMountFolders)
1212                    throws com.liferay.portal.kernel.exception.PortalException {
1213                    return getService()
1214                                       .getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId,
1215                            folderId, status, includeMountFolders);
1216            }
1217    
1218            public static int getFoldersAndFileEntriesAndFileShortcutsCount(
1219                    long repositoryId, long folderId, int status,
1220                    java.lang.String[] mimeTypes, boolean includeMountFolders)
1221                    throws com.liferay.portal.kernel.exception.PortalException {
1222                    return getService()
1223                                       .getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId,
1224                            folderId, status, mimeTypes, includeMountFolders);
1225            }
1226    
1227            /**
1228            * Returns the number of immediate subfolders of the parent folder.
1229            *
1230            * @param repositoryId the primary key of the folder's repository
1231            * @param parentFolderId the primary key of the folder's parent folder
1232            * @return the number of immediate subfolders of the parent folder
1233            * @throws PortalException if the parent folder could not be found
1234            */
1235            public static int getFoldersCount(long repositoryId, long parentFolderId)
1236                    throws com.liferay.portal.kernel.exception.PortalException {
1237                    return getService().getFoldersCount(repositoryId, parentFolderId);
1238            }
1239    
1240            /**
1241            * Returns the number of immediate subfolders of the parent folder,
1242            * optionally including mount folders for third-party repositories.
1243            *
1244            * @param repositoryId the primary key of the folder's repository
1245            * @param parentFolderId the primary key of the folder's parent folder
1246            * @param includeMountFolders whether to include mount folders for
1247            third-party repositories
1248            * @return the number of immediate subfolders of the parent folder
1249            * @throws PortalException if the parent folder could not be found
1250            */
1251            public static int getFoldersCount(long repositoryId, long parentFolderId,
1252                    boolean includeMountFolders)
1253                    throws com.liferay.portal.kernel.exception.PortalException {
1254                    return getService()
1255                                       .getFoldersCount(repositoryId, parentFolderId,
1256                            includeMountFolders);
1257            }
1258    
1259            /**
1260            * Returns the number of immediate subfolders of the parent folder,
1261            * optionally including mount folders for third-party repositories.
1262            *
1263            * @param repositoryId the primary key of the folder's repository
1264            * @param parentFolderId the primary key of the folder's parent folder
1265            * @param status the workflow status
1266            * @param includeMountFolders whether to include mount folders for
1267            third-party repositories
1268            * @return the number of immediate subfolders of the parent folder
1269            * @throws PortalException if the parent folder could not be found
1270            */
1271            public static int getFoldersCount(long repositoryId, long parentFolderId,
1272                    int status, boolean includeMountFolders)
1273                    throws com.liferay.portal.kernel.exception.PortalException {
1274                    return getService()
1275                                       .getFoldersCount(repositoryId, parentFolderId, status,
1276                            includeMountFolders);
1277            }
1278    
1279            /**
1280            * Returns the number of immediate subfolders and file entries across the
1281            * folders.
1282            *
1283            * @param repositoryId the primary key of the repository
1284            * @param folderIds the primary keys of folders from which to count
1285            immediate subfolders and file entries
1286            * @param status the workflow status
1287            * @return the number of immediate subfolders and file entries across the
1288            folders
1289            * @throws PortalException if the repository could not be found
1290            */
1291            public static int getFoldersFileEntriesCount(long repositoryId,
1292                    java.util.List<java.lang.Long> folderIds, int status)
1293                    throws com.liferay.portal.kernel.exception.PortalException {
1294                    return getService()
1295                                       .getFoldersFileEntriesCount(repositoryId, folderIds, status);
1296            }
1297    
1298            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1299                    long groupId, long userId, long rootFolderId,
1300                    java.lang.String[] mimeTypes, int status, int start, int end,
1301                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
1302                    throws com.liferay.portal.kernel.exception.PortalException {
1303                    return getService()
1304                                       .getGroupFileEntries(groupId, userId, rootFolderId,
1305                            mimeTypes, status, start, end, obc);
1306            }
1307    
1308            /**
1309            * Returns an ordered range of all the file entries in the group starting at
1310            * the root folder that are stored within the Liferay repository. This
1311            * method is primarily used to search for recently modified file entries. It
1312            * can be limited to the file entries modified by a given user.
1313            *
1314            * <p>
1315            * Useful when paginating results. Returns a maximum of <code>end -
1316            * start</code> instances. <code>start</code> and <code>end</code> are not
1317            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1318            * refers to the first result in the set. Setting both <code>start</code>
1319            * and <code>end</code> to {@link
1320            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1321            * result set.
1322            * </p>
1323            *
1324            * @param groupId the primary key of the group
1325            * @param userId the primary key of the user who created the file
1326            (optionally <code>0</code>)
1327            * @param rootFolderId the primary key of the root folder to begin the
1328            search
1329            * @param start the lower bound of the range of results
1330            * @param end the upper bound of the range of results (not inclusive)
1331            * @return the range of matching file entries ordered by date modified
1332            * @throws PortalException if the group could not be found
1333            */
1334            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1335                    long groupId, long userId, long rootFolderId, int start, int end)
1336                    throws com.liferay.portal.kernel.exception.PortalException {
1337                    return getService()
1338                                       .getGroupFileEntries(groupId, userId, rootFolderId, start,
1339                            end);
1340            }
1341    
1342            /**
1343            * Returns an ordered range of all the file entries in the group starting at
1344            * the root folder that are stored within the Liferay repository. This
1345            * method is primarily used to search for recently modified file entries. It
1346            * can be limited to the file entries modified by a given user.
1347            *
1348            * <p>
1349            * Useful when paginating results. Returns a maximum of <code>end -
1350            * start</code> instances. <code>start</code> and <code>end</code> are not
1351            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1352            * refers to the first result in the set. Setting both <code>start</code>
1353            * and <code>end</code> to {@link
1354            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1355            * result set.
1356            * </p>
1357            *
1358            * @param groupId the primary key of the group
1359            * @param userId the primary key of the user who created the file
1360            (optionally <code>0</code>)
1361            * @param rootFolderId the primary key of the root folder to begin the
1362            search
1363            * @param start the lower bound of the range of results
1364            * @param end the upper bound of the range of results (not inclusive)
1365            * @param obc the comparator to order the file entries (optionally
1366            <code>null</code>)
1367            * @return the range of matching file entries ordered by comparator
1368            <code>obc</code>
1369            * @throws PortalException if the group could not be found
1370            */
1371            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1372                    long groupId, long userId, long rootFolderId, int start, int end,
1373                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
1374                    throws com.liferay.portal.kernel.exception.PortalException {
1375                    return getService()
1376                                       .getGroupFileEntries(groupId, userId, rootFolderId, start,
1377                            end, obc);
1378            }
1379    
1380            /**
1381            * Returns an ordered range of all the file entries in the group starting at
1382            * the repository default parent folder that are stored within the Liferay
1383            * repository. This method is primarily used to search for recently modified
1384            * file entries. It can be limited to the file entries modified by a given
1385            * user.
1386            *
1387            * <p>
1388            * Useful when paginating results. Returns a maximum of <code>end -
1389            * start</code> instances. <code>start</code> and <code>end</code> are not
1390            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1391            * refers to the first result in the set. Setting both <code>start</code>
1392            * and <code>end</code> to {@link
1393            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1394            * result set.
1395            * </p>
1396            *
1397            * @param groupId the primary key of the group
1398            * @param userId the primary key of the user who created the file
1399            (optionally <code>0</code>)
1400            * @param start the lower bound of the range of results
1401            * @param end the upper bound of the range of results (not inclusive)
1402            * @return the range of matching file entries ordered by date modified
1403            * @throws PortalException if the group could not be found
1404            */
1405            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1406                    long groupId, long userId, int start, int end)
1407                    throws com.liferay.portal.kernel.exception.PortalException {
1408                    return getService().getGroupFileEntries(groupId, userId, start, end);
1409            }
1410    
1411            /**
1412            * Returns an ordered range of all the file entries in the group that are
1413            * stored within the Liferay repository. This method is primarily used to
1414            * search for recently modified file entries. It can be limited to the file
1415            * entries modified by a given user.
1416            *
1417            * <p>
1418            * Useful when paginating results. Returns a maximum of <code>end -
1419            * start</code> instances. <code>start</code> and <code>end</code> are not
1420            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1421            * refers to the first result in the set. Setting both <code>start</code>
1422            * and <code>end</code> to {@link
1423            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1424            * result set.
1425            * </p>
1426            *
1427            * @param groupId the primary key of the group
1428            * @param userId the primary key of the user who created the file
1429            (optionally <code>0</code>)
1430            * @param start the lower bound of the range of results
1431            * @param end the upper bound of the range of results (not inclusive)
1432            * @param obc the comparator to order the file entries (optionally
1433            <code>null</code>)
1434            * @return the range of matching file entries ordered by comparator
1435            <code>obc</code>
1436            * @throws PortalException if the group could not be found
1437            */
1438            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1439                    long groupId, long userId, int start, int end,
1440                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
1441                    throws com.liferay.portal.kernel.exception.PortalException {
1442                    return getService().getGroupFileEntries(groupId, userId, start, end, obc);
1443            }
1444    
1445            /**
1446            * Returns the number of file entries in a group starting at the repository
1447            * default parent folder that are stored within the Liferay repository. This
1448            * method is primarily used to search for recently modified file entries. It
1449            * can be limited to the file entries modified by a given user.
1450            *
1451            * @param groupId the primary key of the group
1452            * @param userId the primary key of the user who created the file
1453            (optionally <code>0</code>)
1454            * @return the number of matching file entries
1455            * @throws PortalException if the group could not be found
1456            */
1457            public static int getGroupFileEntriesCount(long groupId, long userId)
1458                    throws com.liferay.portal.kernel.exception.PortalException {
1459                    return getService().getGroupFileEntriesCount(groupId, userId);
1460            }
1461    
1462            /**
1463            * Returns the number of file entries in a group starting at the root folder
1464            * that are stored within the Liferay repository. This method is primarily
1465            * used to search for recently modified file entries. It can be limited to
1466            * the file entries modified by a given user.
1467            *
1468            * @param groupId the primary key of the group
1469            * @param userId the primary key of the user who created the file
1470            (optionally <code>0</code>)
1471            * @param rootFolderId the primary key of the root folder to begin the
1472            search
1473            * @return the number of matching file entries
1474            * @throws PortalException if the group could not be found
1475            */
1476            public static int getGroupFileEntriesCount(long groupId, long userId,
1477                    long rootFolderId)
1478                    throws com.liferay.portal.kernel.exception.PortalException {
1479                    return getService()
1480                                       .getGroupFileEntriesCount(groupId, userId, rootFolderId);
1481            }
1482    
1483            public static int getGroupFileEntriesCount(long groupId, long userId,
1484                    long rootFolderId, java.lang.String[] mimeTypes, int status)
1485                    throws com.liferay.portal.kernel.exception.PortalException {
1486                    return getService()
1487                                       .getGroupFileEntriesCount(groupId, userId, rootFolderId,
1488                            mimeTypes, status);
1489            }
1490    
1491            /**
1492            * Returns all immediate subfolders of the parent folder that are used for
1493            * mounting third-party repositories. This method is only supported by the
1494            * Liferay repository.
1495            *
1496            * @param repositoryId the primary key of the folder's repository
1497            * @param parentFolderId the primary key of the folder's parent folder
1498            * @return the immediate subfolders of the parent folder that are used for
1499            mounting third-party repositories
1500            * @throws PortalException if the repository or parent folder could not be
1501            found
1502            */
1503            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders(
1504                    long repositoryId, long parentFolderId)
1505                    throws com.liferay.portal.kernel.exception.PortalException {
1506                    return getService().getMountFolders(repositoryId, parentFolderId);
1507            }
1508    
1509            /**
1510            * Returns a range of all the immediate subfolders of the parent folder that
1511            * are used for mounting third-party repositories. This method is only
1512            * supported by the Liferay repository.
1513            *
1514            * <p>
1515            * Useful when paginating results. Returns a maximum of <code>end -
1516            * start</code> instances. <code>start</code> and <code>end</code> are not
1517            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1518            * refers to the first result in the set. Setting both <code>start</code>
1519            * and <code>end</code> to {@link
1520            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1521            * result set.
1522            * </p>
1523            *
1524            * @param repositoryId the primary key of the repository
1525            * @param parentFolderId the primary key of the parent folder
1526            * @param start the lower bound of the range of results
1527            * @param end the upper bound of the range of results (not inclusive)
1528            * @return the range of immediate subfolders of the parent folder that are
1529            used for mounting third-party repositories
1530            * @throws PortalException if the repository or parent folder could not be
1531            found
1532            */
1533            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders(
1534                    long repositoryId, long parentFolderId, int start, int end)
1535                    throws com.liferay.portal.kernel.exception.PortalException {
1536                    return getService()
1537                                       .getMountFolders(repositoryId, parentFolderId, start, end);
1538            }
1539    
1540            /**
1541            * Returns an ordered range of all the immediate subfolders of the parent
1542            * folder that are used for mounting third-party repositories. This method
1543            * is only supported by the Liferay repository.
1544            *
1545            * <p>
1546            * Useful when paginating results. Returns a maximum of <code>end -
1547            * start</code> instances. <code>start</code> and <code>end</code> are not
1548            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1549            * refers to the first result in the set. Setting both <code>start</code>
1550            * and <code>end</code> to {@link
1551            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1552            * result set.
1553            * </p>
1554            *
1555            * @param repositoryId the primary key of the folder's repository
1556            * @param parentFolderId the primary key of the folder's parent folder
1557            * @param start the lower bound of the range of results
1558            * @param end the upper bound of the range of results (not inclusive)
1559            * @param obc the comparator to order the folders (optionally
1560            <code>null</code>)
1561            * @return the range of immediate subfolders of the parent folder that are
1562            used for mounting third-party repositories ordered by comparator
1563            <code>obc</code>
1564            * @throws PortalException if the repository or parent folder could not be
1565            found
1566            */
1567            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders(
1568                    long repositoryId, long parentFolderId, int start, int end,
1569                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1570                    throws com.liferay.portal.kernel.exception.PortalException {
1571                    return getService()
1572                                       .getMountFolders(repositoryId, parentFolderId, start, end,
1573                            obc);
1574            }
1575    
1576            /**
1577            * Returns the number of immediate subfolders of the parent folder that are
1578            * used for mounting third-party repositories. This method is only supported
1579            * by the Liferay repository.
1580            *
1581            * @param repositoryId the primary key of the repository
1582            * @param parentFolderId the primary key of the parent folder
1583            * @return the number of folders of the parent folder that are used for
1584            mounting third-party repositories
1585            * @throws PortalException if the repository or parent folder could not be
1586            found
1587            */
1588            public static int getMountFoldersCount(long repositoryId,
1589                    long parentFolderId)
1590                    throws com.liferay.portal.kernel.exception.PortalException {
1591                    return getService().getMountFoldersCount(repositoryId, parentFolderId);
1592            }
1593    
1594            /**
1595            * Returns all the descendant folders of the folder with the primary key.
1596            *
1597            * @param repositoryId the primary key of the repository
1598            * @param folderId the primary key of the folder
1599            * @return the descendant folders of the folder with the primary key
1600            * @throws PortalException if the repository or parent folder could not be
1601            found
1602            */
1603            public static java.util.List<java.lang.Long> getSubfolderIds(
1604                    long repositoryId, long folderId)
1605                    throws com.liferay.portal.kernel.exception.PortalException {
1606                    return getService().getSubfolderIds(repositoryId, folderId);
1607            }
1608    
1609            /**
1610            * Returns descendant folders of the folder with the primary key, optionally
1611            * limiting to one level deep.
1612            *
1613            * @param repositoryId the primary key of the repository
1614            * @param folderId the primary key of the folder
1615            * @param recurse whether to recurse through each subfolder
1616            * @return the descendant folders of the folder with the primary key
1617            * @throws PortalException if the repository or parent folder could not be
1618            found
1619            */
1620            public static java.util.List<java.lang.Long> getSubfolderIds(
1621                    long repositoryId, long folderId, boolean recurse)
1622                    throws com.liferay.portal.kernel.exception.PortalException {
1623                    return getService().getSubfolderIds(repositoryId, folderId, recurse);
1624            }
1625    
1626            public static void getSubfolderIds(long repositoryId,
1627                    java.util.List<java.lang.Long> folderIds, long folderId)
1628                    throws com.liferay.portal.kernel.exception.PortalException {
1629                    getService().getSubfolderIds(repositoryId, folderIds, folderId);
1630            }
1631    
1632            /**
1633            * Returns all the temporary file entry names.
1634            *
1635            * @param groupId the primary key of the group
1636            * @param folderId the primary key of the folder where the file entry will
1637            eventually reside
1638            * @param folderName the temporary folder's name
1639            * @return the temporary file entry names
1640            * @throws PortalException if the folder was invalid
1641            * @see #addTempFileEntry(long, long, String, String, File, String)
1642            * @see com.liferay.portal.kernel.util.TempFileEntryUtil
1643            */
1644            public static java.lang.String[] getTempFileNames(long groupId,
1645                    long folderId, java.lang.String folderName)
1646                    throws com.liferay.portal.kernel.exception.PortalException {
1647                    return getService().getTempFileNames(groupId, folderId, folderName);
1648            }
1649    
1650            /**
1651            * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long,
1652            ServiceContext)}
1653            */
1654            @Deprecated
1655            public static com.liferay.portal.model.Lock lockFileEntry(long fileEntryId)
1656                    throws com.liferay.portal.kernel.exception.PortalException {
1657                    return getService().lockFileEntry(fileEntryId);
1658            }
1659    
1660            /**
1661            * @deprecated As of 6.2.0, replaced by {@link #checkOutFileEntry(long,
1662            String, long, ServiceContext)}
1663            */
1664            @Deprecated
1665            public static com.liferay.portal.model.Lock lockFileEntry(
1666                    long fileEntryId, java.lang.String owner, long expirationTime)
1667                    throws com.liferay.portal.kernel.exception.PortalException {
1668                    return getService().lockFileEntry(fileEntryId, owner, expirationTime);
1669            }
1670    
1671            /**
1672            * Locks the folder. This method is primarily used by WebDAV.
1673            *
1674            * @param repositoryId the primary key of the repository
1675            * @param folderId the primary key of the folder
1676            * @return the lock object
1677            * @throws PortalException if the repository or folder could not be found
1678            */
1679            public static com.liferay.portal.model.Lock lockFolder(long repositoryId,
1680                    long folderId)
1681                    throws com.liferay.portal.kernel.exception.PortalException {
1682                    return getService().lockFolder(repositoryId, folderId);
1683            }
1684    
1685            /**
1686            * Locks the folder. This method is primarily used by WebDAV.
1687            *
1688            * @param repositoryId the primary key of the repository
1689            * @param folderId the primary key of the folder
1690            * @param owner the owner string for the checkout (optionally
1691            <code>null</code>)
1692            * @param inheritable whether the lock must propagate to descendants
1693            * @param expirationTime the time in milliseconds before the lock expires.
1694            If the value is <code>0</code>, the default expiration time will
1695            be used from <code>portal.properties>.
1696            * @return the lock object
1697            * @throws PortalException if the repository or folder could not be found
1698            */
1699            public static com.liferay.portal.model.Lock lockFolder(long repositoryId,
1700                    long folderId, java.lang.String owner, boolean inheritable,
1701                    long expirationTime)
1702                    throws com.liferay.portal.kernel.exception.PortalException {
1703                    return getService()
1704                                       .lockFolder(repositoryId, folderId, owner, inheritable,
1705                            expirationTime);
1706            }
1707    
1708            /**
1709            * Moves the file entry 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 moveFileEntry(
1719                    long fileEntryId, long newFolderId,
1720                    com.liferay.portal.service.ServiceContext serviceContext)
1721                    throws com.liferay.portal.kernel.exception.PortalException {
1722                    return getService()
1723                                       .moveFileEntry(fileEntryId, newFolderId, serviceContext);
1724            }
1725    
1726            /**
1727            * Moves the file entry from a trashed folder to the new folder.
1728            *
1729            * @param fileEntryId the primary key of the file entry
1730            * @param newFolderId the primary key of the new folder
1731            * @param serviceContext the service context to be applied
1732            * @return the file entry
1733            * @throws PortalException if the file entry or the new folder could not be
1734            found
1735            */
1736            public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryFromTrash(
1737                    long fileEntryId, long newFolderId,
1738                    com.liferay.portal.service.ServiceContext serviceContext)
1739                    throws com.liferay.portal.kernel.exception.PortalException {
1740                    return getService()
1741                                       .moveFileEntryFromTrash(fileEntryId, newFolderId,
1742                            serviceContext);
1743            }
1744    
1745            /**
1746            * Moves the file entry with the primary key to the trash portlet.
1747            *
1748            * @param fileEntryId the primary key of the file entry
1749            * @return the file entry
1750            * @throws PortalException if the file entry could not be found
1751            */
1752            public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryToTrash(
1753                    long fileEntryId)
1754                    throws com.liferay.portal.kernel.exception.PortalException {
1755                    return getService().moveFileEntryToTrash(fileEntryId);
1756            }
1757    
1758            /**
1759            * Moves the file shortcut from a trashed folder to the new folder.
1760            *
1761            * @param fileShortcutId the primary key of the file shortcut
1762            * @param newFolderId the primary key of the new folder
1763            * @param serviceContext the service context to be applied
1764            * @return the file shortcut
1765            * @throws PortalException if the file entry or the new folder could not be
1766            found
1767            */
1768            public static com.liferay.portlet.documentlibrary.model.DLFileShortcut moveFileShortcutFromTrash(
1769                    long fileShortcutId, long newFolderId,
1770                    com.liferay.portal.service.ServiceContext serviceContext)
1771                    throws com.liferay.portal.kernel.exception.PortalException {
1772                    return getService()
1773                                       .moveFileShortcutFromTrash(fileShortcutId, newFolderId,
1774                            serviceContext);
1775            }
1776    
1777            /**
1778            * Moves the file shortcut with the primary key to the trash portlet.
1779            *
1780            * @param fileShortcutId the primary key of the file shortcut
1781            * @return the file shortcut
1782            * @throws PortalException if the file shortcut could not be found
1783            */
1784            public static com.liferay.portlet.documentlibrary.model.DLFileShortcut moveFileShortcutToTrash(
1785                    long fileShortcutId)
1786                    throws com.liferay.portal.kernel.exception.PortalException {
1787                    return getService().moveFileShortcutToTrash(fileShortcutId);
1788            }
1789    
1790            /**
1791            * Moves the folder to the new parent folder with the primary key.
1792            *
1793            * @param folderId the primary key of the folder
1794            * @param parentFolderId the primary key of the new parent folder
1795            * @param serviceContext the service context to be applied
1796            * @return the file entry
1797            * @throws PortalException if the folder could not be found
1798            */
1799            public static com.liferay.portal.kernel.repository.model.Folder moveFolder(
1800                    long folderId, long parentFolderId,
1801                    com.liferay.portal.service.ServiceContext serviceContext)
1802                    throws com.liferay.portal.kernel.exception.PortalException {
1803                    return getService().moveFolder(folderId, parentFolderId, serviceContext);
1804            }
1805    
1806            /**
1807            * Moves the folder with the primary key from the trash portlet to the new
1808            * parent folder with the primary key.
1809            *
1810            * @param folderId the primary key of the folder
1811            * @param parentFolderId the primary key of the new parent folder
1812            * @param serviceContext the service context to be applied
1813            * @return the file entry
1814            * @throws PortalException if the folder could not be found
1815            */
1816            public static com.liferay.portal.kernel.repository.model.Folder moveFolderFromTrash(
1817                    long folderId, long parentFolderId,
1818                    com.liferay.portal.service.ServiceContext serviceContext)
1819                    throws com.liferay.portal.kernel.exception.PortalException {
1820                    return getService()
1821                                       .moveFolderFromTrash(folderId, parentFolderId, serviceContext);
1822            }
1823    
1824            /**
1825            * Moves the folder with the primary key to the trash portlet.
1826            *
1827            * @param folderId the primary key of the folder
1828            * @return the file entry
1829            * @throws PortalException if the folder could not be found
1830            */
1831            public static com.liferay.portal.kernel.repository.model.Folder moveFolderToTrash(
1832                    long folderId)
1833                    throws com.liferay.portal.kernel.exception.PortalException {
1834                    return getService().moveFolderToTrash(folderId);
1835            }
1836    
1837            /**
1838            * Refreshes the lock for the file entry. This method is primarily used by
1839            * WebDAV.
1840            *
1841            * @param lockUuid the lock's UUID
1842            * @param companyId the primary key of the file entry's company
1843            * @param expirationTime the time in milliseconds before the lock expires.
1844            If the value is <code>0</code>, the default expiration time will
1845            be used from <code>portal.properties>.
1846            * @return the lock object
1847            * @throws PortalException if the file entry or lock could not be found
1848            */
1849            public static com.liferay.portal.model.Lock refreshFileEntryLock(
1850                    java.lang.String lockUuid, long companyId, long expirationTime)
1851                    throws com.liferay.portal.kernel.exception.PortalException {
1852                    return getService()
1853                                       .refreshFileEntryLock(lockUuid, companyId, expirationTime);
1854            }
1855    
1856            /**
1857            * Refreshes the lock for the folder. This method is primarily used by
1858            * WebDAV.
1859            *
1860            * @param lockUuid the lock's UUID
1861            * @param companyId the primary key of the file entry's company
1862            * @param expirationTime the time in milliseconds before the lock expires.
1863            If the value is <code>0</code>, the default expiration time will
1864            be used from <code>portal.properties>.
1865            * @return the lock object
1866            * @throws PortalException if the folder or lock could not be found
1867            */
1868            public static com.liferay.portal.model.Lock refreshFolderLock(
1869                    java.lang.String lockUuid, long companyId, long expirationTime)
1870                    throws com.liferay.portal.kernel.exception.PortalException {
1871                    return getService()
1872                                       .refreshFolderLock(lockUuid, companyId, expirationTime);
1873            }
1874    
1875            /**
1876            * Restores the file entry with the primary key from the trash portlet.
1877            *
1878            * @param fileEntryId the primary key of the file entry
1879            * @throws PortalException if the file entry could not be found
1880            */
1881            public static void restoreFileEntryFromTrash(long fileEntryId)
1882                    throws com.liferay.portal.kernel.exception.PortalException {
1883                    getService().restoreFileEntryFromTrash(fileEntryId);
1884            }
1885    
1886            /**
1887            * Restores the file shortcut with the primary key from the trash portlet.
1888            *
1889            * @param fileShortcutId the primary key of the file shortcut
1890            * @throws PortalException if the file shortcut could not be found
1891            */
1892            public static void restoreFileShortcutFromTrash(long fileShortcutId)
1893                    throws com.liferay.portal.kernel.exception.PortalException {
1894                    getService().restoreFileShortcutFromTrash(fileShortcutId);
1895            }
1896    
1897            /**
1898            * Restores the folder with the primary key from the trash portlet.
1899            *
1900            * @param folderId the primary key of the folder
1901            * @throws PortalException if the folder could not be found
1902            */
1903            public static void restoreFolderFromTrash(long folderId)
1904                    throws com.liferay.portal.kernel.exception.PortalException {
1905                    getService().restoreFolderFromTrash(folderId);
1906            }
1907    
1908            /**
1909            * Reverts the file entry to a previous version. A new version will be
1910            * created based on the previous version and metadata.
1911            *
1912            * @param fileEntryId the primary key of the file entry
1913            * @param version the version to revert back to
1914            * @param serviceContext the service context to be applied
1915            * @throws PortalException if the file entry or version could not be found
1916            */
1917            public static void revertFileEntry(long fileEntryId,
1918                    java.lang.String version,
1919                    com.liferay.portal.service.ServiceContext serviceContext)
1920                    throws com.liferay.portal.kernel.exception.PortalException {
1921                    getService().revertFileEntry(fileEntryId, version, serviceContext);
1922            }
1923    
1924            public static com.liferay.portal.kernel.search.Hits search(
1925                    long repositoryId, long creatorUserId, long folderId,
1926                    java.lang.String[] mimeTypes, int status, int start, int end)
1927                    throws com.liferay.portal.kernel.exception.PortalException {
1928                    return getService()
1929                                       .search(repositoryId, creatorUserId, folderId, mimeTypes,
1930                            status, start, end);
1931            }
1932    
1933            public static com.liferay.portal.kernel.search.Hits search(
1934                    long repositoryId, long creatorUserId, int status, int start, int end)
1935                    throws com.liferay.portal.kernel.exception.PortalException {
1936                    return getService()
1937                                       .search(repositoryId, creatorUserId, status, start, end);
1938            }
1939    
1940            public static com.liferay.portal.kernel.search.Hits search(
1941                    long repositoryId,
1942                    com.liferay.portal.kernel.search.SearchContext searchContext)
1943                    throws com.liferay.portal.kernel.search.SearchException {
1944                    return getService().search(repositoryId, searchContext);
1945            }
1946    
1947            public static com.liferay.portal.kernel.search.Hits search(
1948                    long repositoryId,
1949                    com.liferay.portal.kernel.search.SearchContext searchContext,
1950                    com.liferay.portal.kernel.search.Query query)
1951                    throws com.liferay.portal.kernel.search.SearchException {
1952                    return getService().search(repositoryId, searchContext, query);
1953            }
1954    
1955            /**
1956            * Sets the Spring bean ID for this bean.
1957            *
1958            * @param beanIdentifier the Spring bean ID for this bean
1959            */
1960            public static void setBeanIdentifier(java.lang.String beanIdentifier) {
1961                    getService().setBeanIdentifier(beanIdentifier);
1962            }
1963    
1964            /**
1965            * Subscribe the user to changes in documents of the file entry type. This
1966            * method is only supported by the Liferay repository.
1967            *
1968            * @param groupId the primary key of the file entry type's group
1969            * @param fileEntryTypeId the primary key of the file entry type
1970            * @throws PortalException if the user or group could not be found, or if
1971            subscribing was not permissible
1972            */
1973            public static void subscribeFileEntryType(long groupId, long fileEntryTypeId)
1974                    throws com.liferay.portal.kernel.exception.PortalException {
1975                    getService().subscribeFileEntryType(groupId, fileEntryTypeId);
1976            }
1977    
1978            /**
1979            * Subscribe the user to document changes in the folder. This method is only
1980            * supported by the Liferay repository.
1981            *
1982            * @param groupId the primary key of the folder's group
1983            * @param folderId the primary key of the folder
1984            * @throws PortalException if the user or group could not be found, or if
1985            subscribing was not permissible
1986            */
1987            public static void subscribeFolder(long groupId, long folderId)
1988                    throws com.liferay.portal.kernel.exception.PortalException {
1989                    getService().subscribeFolder(groupId, folderId);
1990            }
1991    
1992            /**
1993            * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
1994            boolean, String, ServiceContext)}.
1995            */
1996            @Deprecated
1997            public static void unlockFileEntry(long fileEntryId)
1998                    throws com.liferay.portal.kernel.exception.PortalException {
1999                    getService().unlockFileEntry(fileEntryId);
2000            }
2001    
2002            /**
2003            * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
2004            String)}.
2005            */
2006            @Deprecated
2007            public static void unlockFileEntry(long fileEntryId,
2008                    java.lang.String lockUuid)
2009                    throws com.liferay.portal.kernel.exception.PortalException {
2010                    getService().unlockFileEntry(fileEntryId, lockUuid);
2011            }
2012    
2013            /**
2014            * Unlocks the folder. This method is primarily used by WebDAV.
2015            *
2016            * @param repositoryId the primary key of the repository
2017            * @param folderId the primary key of the folder
2018            * @param lockUuid the lock's UUID
2019            * @throws PortalException if the repository or folder could not be found
2020            */
2021            public static void unlockFolder(long repositoryId, long folderId,
2022                    java.lang.String lockUuid)
2023                    throws com.liferay.portal.kernel.exception.PortalException {
2024                    getService().unlockFolder(repositoryId, folderId, lockUuid);
2025            }
2026    
2027            /**
2028            * Unlocks the folder. This method is primarily used by WebDAV.
2029            *
2030            * @param repositoryId the primary key of the repository
2031            * @param parentFolderId the primary key of the parent folder
2032            * @param name the folder's name
2033            * @param lockUuid the lock's UUID
2034            * @throws PortalException if the repository or folder could not be found
2035            */
2036            public static void unlockFolder(long repositoryId, long parentFolderId,
2037                    java.lang.String name, java.lang.String lockUuid)
2038                    throws com.liferay.portal.kernel.exception.PortalException {
2039                    getService().unlockFolder(repositoryId, parentFolderId, name, lockUuid);
2040            }
2041    
2042            /**
2043            * Unsubscribe the user from changes in documents of the file entry type.
2044            * This method is only supported by the Liferay repository.
2045            *
2046            * @param groupId the primary key of the file entry type's group
2047            * @param fileEntryTypeId the primary key of the file entry type
2048            * @throws PortalException if the user or group could not be found, or if
2049            unsubscribing was not permissible
2050            */
2051            public static void unsubscribeFileEntryType(long groupId,
2052                    long fileEntryTypeId)
2053                    throws com.liferay.portal.kernel.exception.PortalException {
2054                    getService().unsubscribeFileEntryType(groupId, fileEntryTypeId);
2055            }
2056    
2057            /**
2058            * Unsubscribe the user from document changes in the folder. This method is
2059            * only supported by the Liferay repository.
2060            *
2061            * @param groupId the primary key of the folder's group
2062            * @param folderId the primary key of the folder
2063            * @throws PortalException if the user or group could not be found, or if
2064            unsubscribing was not permissible
2065            */
2066            public static void unsubscribeFolder(long groupId, long folderId)
2067                    throws com.liferay.portal.kernel.exception.PortalException {
2068                    getService().unsubscribeFolder(groupId, folderId);
2069            }
2070    
2071            /**
2072            * Updates a file entry and associated metadata based on a byte array
2073            * object. If the file data is <code>null</code>, then only the associated
2074            * metadata (i.e., <code>title</code>, <code>description</code>, and
2075            * parameters in the <code>serviceContext</code>) will be updated.
2076            *
2077            * <p>
2078            * This method takes two file names, the <code>sourceFileName</code> and the
2079            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
2080            * name of the actual file being uploaded. The <code>title</code>
2081            * corresponds to a name the client wishes to assign this file after it has
2082            * been uploaded to the portal.
2083            * </p>
2084            *
2085            * @param fileEntryId the primary key of the file entry
2086            * @param sourceFileName the original file's name (optionally
2087            <code>null</code>)
2088            * @param mimeType the file's MIME type (optionally <code>null</code>)
2089            * @param title the new name to be assigned to the file (optionally <code>
2090            <code>null</code></code>)
2091            * @param description the file's new description
2092            * @param changeLog the file's version change log (optionally
2093            <code>null</code>)
2094            * @param majorVersion whether the new file version is a major version
2095            * @param bytes the file's data (optionally <code>null</code>)
2096            * @param serviceContext the service context to be applied. Can set the
2097            asset category IDs, asset tag names, and expando bridge
2098            attributes for the file entry. In a Liferay repository, it may
2099            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
2100            type </li> <li> fieldsMap - mapping for fields associated with a
2101            custom file entry type </li> </ul>
2102            * @return the file entry
2103            * @throws PortalException if the file entry could not be found
2104            */
2105            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
2106                    long fileEntryId, java.lang.String sourceFileName,
2107                    java.lang.String mimeType, java.lang.String title,
2108                    java.lang.String description, java.lang.String changeLog,
2109                    boolean majorVersion, byte[] bytes,
2110                    com.liferay.portal.service.ServiceContext serviceContext)
2111                    throws com.liferay.portal.kernel.exception.PortalException {
2112                    return getService()
2113                                       .updateFileEntry(fileEntryId, sourceFileName, mimeType,
2114                            title, description, changeLog, majorVersion, bytes, serviceContext);
2115            }
2116    
2117            /**
2118            * Updates a file entry and associated metadata based on a {@link
2119            * java.io.File} object. If the file data is <code>null</code>, then only
2120            * the associated metadata (i.e., <code>title</code>,
2121            * <code>description</code>, and parameters in the
2122            * <code>serviceContext</code>) will be updated.
2123            *
2124            * <p>
2125            * This method takes two file names, the <code>sourceFileName</code> and the
2126            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
2127            * name of the actual file being uploaded. The <code>title</code>
2128            * corresponds to a name the client wishes to assign this file after it has
2129            * been uploaded to the portal.
2130            * </p>
2131            *
2132            * @param fileEntryId the primary key of the file entry
2133            * @param sourceFileName the original file's name (optionally
2134            <code>null</code>)
2135            * @param mimeType the file's MIME type (optionally <code>null</code>)
2136            * @param title the new name to be assigned to the file (optionally <code>
2137            <code>null</code></code>)
2138            * @param description the file's new description
2139            * @param changeLog the file's version change log (optionally
2140            <code>null</code>)
2141            * @param majorVersion whether the new file version is a major version
2142            * @param file the file's data (optionally <code>null</code>)
2143            * @param serviceContext the service context to be applied. Can set the
2144            asset category IDs, asset tag names, and expando bridge
2145            attributes for the file entry. In a Liferay repository, it may
2146            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
2147            type </li> <li> fieldsMap - mapping for fields associated with a
2148            custom file entry type </li> </ul>
2149            * @return the file entry
2150            * @throws PortalException if the file entry could not be found
2151            */
2152            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
2153                    long fileEntryId, java.lang.String sourceFileName,
2154                    java.lang.String mimeType, java.lang.String title,
2155                    java.lang.String description, java.lang.String changeLog,
2156                    boolean majorVersion, java.io.File file,
2157                    com.liferay.portal.service.ServiceContext serviceContext)
2158                    throws com.liferay.portal.kernel.exception.PortalException {
2159                    return getService()
2160                                       .updateFileEntry(fileEntryId, sourceFileName, mimeType,
2161                            title, description, changeLog, majorVersion, file, serviceContext);
2162            }
2163    
2164            /**
2165            * Updates a file entry and associated metadata based on an {@link
2166            * InputStream} object. If the file data is <code>null</code>, then only the
2167            * associated metadata (i.e., <code>title</code>, <code>description</code>,
2168            * and parameters in the <code>serviceContext</code>) will be updated.
2169            *
2170            * <p>
2171            * This method takes two file names, the <code>sourceFileName</code> and the
2172            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
2173            * name of the actual file being uploaded. The <code>title</code>
2174            * corresponds to a name the client wishes to assign this file after it has
2175            * been uploaded to the portal.
2176            * </p>
2177            *
2178            * @param fileEntryId the primary key of the file entry
2179            * @param sourceFileName the original file's name (optionally
2180            <code>null</code>)
2181            * @param mimeType the file's MIME type (optionally <code>null</code>)
2182            * @param title the new name to be assigned to the file (optionally <code>
2183            <code>null</code></code>)
2184            * @param description the file's new description
2185            * @param changeLog the file's version change log (optionally
2186            <code>null</code>)
2187            * @param majorVersion whether the new file version is a major version
2188            * @param is the file's data (optionally <code>null</code>)
2189            * @param size the file's size (optionally <code>0</code>)
2190            * @param serviceContext the service context to be applied. Can set the
2191            asset category IDs, asset tag names, and expando bridge
2192            attributes for the file entry. In a Liferay repository, it may
2193            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
2194            type </li> <li> fieldsMap - mapping for fields associated with a
2195            custom file entry type </li> </ul>
2196            * @return the file entry
2197            * @throws PortalException if the file entry could not be found
2198            */
2199            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
2200                    long fileEntryId, java.lang.String sourceFileName,
2201                    java.lang.String mimeType, java.lang.String title,
2202                    java.lang.String description, java.lang.String changeLog,
2203                    boolean majorVersion, java.io.InputStream is, long size,
2204                    com.liferay.portal.service.ServiceContext serviceContext)
2205                    throws com.liferay.portal.kernel.exception.PortalException {
2206                    return getService()
2207                                       .updateFileEntry(fileEntryId, sourceFileName, mimeType,
2208                            title, description, changeLog, majorVersion, is, size,
2209                            serviceContext);
2210            }
2211    
2212            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
2213                    long fileEntryId, java.lang.String sourceFileName,
2214                    java.lang.String mimeType, java.lang.String title,
2215                    java.lang.String description, java.lang.String changeLog,
2216                    boolean majorVersion, java.io.File file,
2217                    com.liferay.portal.service.ServiceContext serviceContext)
2218                    throws com.liferay.portal.kernel.exception.PortalException {
2219                    return getService()
2220                                       .updateFileEntryAndCheckIn(fileEntryId, sourceFileName,
2221                            mimeType, title, description, changeLog, majorVersion, file,
2222                            serviceContext);
2223            }
2224    
2225            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
2226                    long fileEntryId, java.lang.String sourceFileName,
2227                    java.lang.String mimeType, java.lang.String title,
2228                    java.lang.String description, java.lang.String changeLog,
2229                    boolean majorVersion, java.io.InputStream is, long size,
2230                    com.liferay.portal.service.ServiceContext serviceContext)
2231                    throws com.liferay.portal.kernel.exception.PortalException {
2232                    return getService()
2233                                       .updateFileEntryAndCheckIn(fileEntryId, sourceFileName,
2234                            mimeType, title, description, changeLog, majorVersion, is, size,
2235                            serviceContext);
2236            }
2237    
2238            /**
2239            * Updates a file shortcut to the existing file entry. This method is only
2240            * supported by the Liferay repository.
2241            *
2242            * @param fileShortcutId the primary key of the file shortcut
2243            * @param folderId the primary key of the file shortcut's parent folder
2244            * @param toFileEntryId the primary key of the file shortcut's file entry
2245            * @param serviceContext the service context to be applied. Can set the
2246            asset category IDs, asset tag names, and expando bridge
2247            attributes for the file entry.
2248            * @return the file shortcut
2249            * @throws PortalException if the file shortcut, folder, or file entry could
2250            not be found
2251            */
2252            public static com.liferay.portlet.documentlibrary.model.DLFileShortcut updateFileShortcut(
2253                    long fileShortcutId, long folderId, long toFileEntryId,
2254                    com.liferay.portal.service.ServiceContext serviceContext)
2255                    throws com.liferay.portal.kernel.exception.PortalException {
2256                    return getService()
2257                                       .updateFileShortcut(fileShortcutId, folderId, toFileEntryId,
2258                            serviceContext);
2259            }
2260    
2261            /**
2262            * Updates the folder.
2263            *
2264            * @param folderId the primary key of the folder
2265            * @param name the folder's new name
2266            * @param description the folder's new description
2267            * @param serviceContext the service context to be applied. In a Liferay
2268            repository, it may include:  <ul> <li> defaultFileEntryTypeId -
2269            the file entry type to default all Liferay file entries to </li>
2270            <li> dlFileEntryTypesSearchContainerPrimaryKeys - a
2271            comma-delimited list of file entry type primary keys allowed in
2272            the given folder and all descendants </li> <li> restrictionType -
2273            specifying restriction type of file entry types allowed </li>
2274            <li> workflowDefinitionXYZ - the workflow definition name
2275            specified per file entry type. The parameter name must be the
2276            string <code>workflowDefinition</code> appended by the
2277            <code>fileEntryTypeId</code> (optionally <code>0</code>).</li>
2278            </ul>
2279            * @return the folder
2280            * @throws PortalException if the current or new parent folder could not be
2281            found or if the new parent folder's information was invalid
2282            */
2283            public static com.liferay.portal.kernel.repository.model.Folder updateFolder(
2284                    long folderId, java.lang.String name, java.lang.String description,
2285                    com.liferay.portal.service.ServiceContext serviceContext)
2286                    throws com.liferay.portal.kernel.exception.PortalException {
2287                    return getService()
2288                                       .updateFolder(folderId, name, description, serviceContext);
2289            }
2290    
2291            /**
2292            * Returns <code>true</code> if the file entry is checked out. This method
2293            * is primarily used by WebDAV.
2294            *
2295            * @param repositoryId the primary key for the repository
2296            * @param fileEntryId the primary key for the file entry
2297            * @param lockUuid the lock's UUID
2298            * @return <code>true</code> if the file entry is checked out;
2299            <code>false</code> otherwise
2300            * @throws PortalException if the file entry could not be found
2301            */
2302            public static boolean verifyFileEntryCheckOut(long repositoryId,
2303                    long fileEntryId, java.lang.String lockUuid)
2304                    throws com.liferay.portal.kernel.exception.PortalException {
2305                    return getService()
2306                                       .verifyFileEntryCheckOut(repositoryId, fileEntryId, lockUuid);
2307            }
2308    
2309            public static boolean verifyFileEntryLock(long repositoryId,
2310                    long fileEntryId, java.lang.String lockUuid)
2311                    throws com.liferay.portal.kernel.exception.PortalException {
2312                    return getService()
2313                                       .verifyFileEntryLock(repositoryId, fileEntryId, lockUuid);
2314            }
2315    
2316            /**
2317            * Returns <code>true</code> if the inheritable lock exists. This method is
2318            * primarily used by WebDAV.
2319            *
2320            * @param repositoryId the primary key for the repository
2321            * @param folderId the primary key for the folder
2322            * @param lockUuid the lock's UUID
2323            * @return <code>true</code> if the inheritable lock exists;
2324            <code>false</code> otherwise
2325            * @throws PortalException if the folder could not be found
2326            */
2327            public static boolean verifyInheritableLock(long repositoryId,
2328                    long folderId, java.lang.String lockUuid)
2329                    throws com.liferay.portal.kernel.exception.PortalException {
2330                    return getService()
2331                                       .verifyInheritableLock(repositoryId, folderId, lockUuid);
2332            }
2333    
2334            public static DLAppService getService() {
2335                    if (_service == null) {
2336                            _service = (DLAppService)PortalBeanLocatorUtil.locate(DLAppService.class.getName());
2337    
2338                            ReferenceRegistry.registerReference(DLAppServiceUtil.class,
2339                                    "_service");
2340                    }
2341    
2342                    return _service;
2343            }
2344    
2345            /**
2346             * @deprecated As of 6.2.0
2347             */
2348            @Deprecated
2349            public void setService(DLAppService service) {
2350            }
2351    
2352            private static DLAppService _service;
2353    }