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