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