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