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