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