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