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