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