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