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 file entry from a trashed folder to the new folder.
1411            *
1412            * @param fileEntryId the primary key of the file entry
1413            * @param newFolderId the primary key of the new folder
1414            * @param serviceContext the service context to be applied
1415            * @return the file entry
1416            */
1417            public com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryFromTrash(
1418                    long fileEntryId, long newFolderId,
1419                    com.liferay.portal.service.ServiceContext serviceContext)
1420                    throws PortalException;
1421    
1422            /**
1423            * Moves the file entry with the primary key to the trash portlet.
1424            *
1425            * @param fileEntryId the primary key of the file entry
1426            * @return the file entry
1427            */
1428            public com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryToTrash(
1429                    long fileEntryId) throws PortalException;
1430    
1431            /**
1432            * Moves the file shortcut from a trashed folder to the new folder.
1433            *
1434            * @param fileShortcutId the primary key of the file shortcut
1435            * @param newFolderId the primary key of the new folder
1436            * @param serviceContext the service context to be applied
1437            * @return the file shortcut
1438            */
1439            public com.liferay.portal.kernel.repository.model.FileShortcut moveFileShortcutFromTrash(
1440                    long fileShortcutId, long newFolderId,
1441                    com.liferay.portal.service.ServiceContext serviceContext)
1442                    throws PortalException;
1443    
1444            /**
1445            * Moves the file shortcut with the primary key to the trash portlet.
1446            *
1447            * @param fileShortcutId the primary key of the file shortcut
1448            * @return the file shortcut
1449            */
1450            public com.liferay.portal.kernel.repository.model.FileShortcut moveFileShortcutToTrash(
1451                    long fileShortcutId) throws PortalException;
1452    
1453            /**
1454            * Moves the folder to the new parent folder with the primary key.
1455            *
1456            * @param folderId the primary key of the folder
1457            * @param parentFolderId the primary key of the new parent folder
1458            * @param serviceContext the service context to be applied
1459            * @return the file entry
1460            */
1461            public com.liferay.portal.kernel.repository.model.Folder moveFolder(
1462                    long folderId, long parentFolderId,
1463                    com.liferay.portal.service.ServiceContext serviceContext)
1464                    throws PortalException;
1465    
1466            /**
1467            * Moves the folder with the primary key from the trash portlet to the new
1468            * parent folder with the primary key.
1469            *
1470            * @param folderId the primary key of the folder
1471            * @param parentFolderId the primary key of the new parent folder
1472            * @param serviceContext the service context to be applied
1473            * @return the file entry
1474            */
1475            public com.liferay.portal.kernel.repository.model.Folder moveFolderFromTrash(
1476                    long folderId, long parentFolderId,
1477                    com.liferay.portal.service.ServiceContext serviceContext)
1478                    throws PortalException;
1479    
1480            /**
1481            * Moves the folder with the primary key to the trash portlet.
1482            *
1483            * @param folderId the primary key of the folder
1484            * @return the file entry
1485            */
1486            public com.liferay.portal.kernel.repository.model.Folder moveFolderToTrash(
1487                    long folderId) throws PortalException;
1488    
1489            /**
1490            * Refreshes the lock for the file entry. This method is primarily used by
1491            * WebDAV.
1492            *
1493            * @param lockUuid the lock's UUID
1494            * @param companyId the primary key of the file entry's company
1495            * @param expirationTime the time in milliseconds before the lock expires.
1496            If the value is <code>0</code>, the default expiration time will
1497            be used from <code>portal.properties>.
1498            * @return the lock object
1499            */
1500            public com.liferay.portal.kernel.lock.Lock refreshFileEntryLock(
1501                    java.lang.String lockUuid, long companyId, long expirationTime)
1502                    throws PortalException;
1503    
1504            /**
1505            * Refreshes the lock for the folder. This method is primarily used by
1506            * WebDAV.
1507            *
1508            * @param lockUuid the lock's UUID
1509            * @param companyId the primary key of the file entry's company
1510            * @param expirationTime the time in milliseconds before the lock expires.
1511            If the value is <code>0</code>, the default expiration time will
1512            be used from <code>portal.properties>.
1513            * @return the lock object
1514            */
1515            public com.liferay.portal.kernel.lock.Lock refreshFolderLock(
1516                    java.lang.String lockUuid, long companyId, long expirationTime)
1517                    throws PortalException;
1518    
1519            /**
1520            * Restores the file entry with the primary key from the trash portlet.
1521            *
1522            * @param fileEntryId the primary key of the file entry
1523            */
1524            public void restoreFileEntryFromTrash(long fileEntryId)
1525                    throws PortalException;
1526    
1527            /**
1528            * Restores the file shortcut with the primary key from the trash portlet.
1529            *
1530            * @param fileShortcutId the primary key of the file shortcut
1531            */
1532            public void restoreFileShortcutFromTrash(long fileShortcutId)
1533                    throws PortalException;
1534    
1535            /**
1536            * Restores the folder with the primary key from the trash portlet.
1537            *
1538            * @param folderId the primary key of the folder
1539            */
1540            public void restoreFolderFromTrash(long folderId) throws PortalException;
1541    
1542            /**
1543            * Reverts the file entry to a previous version. A new version will be
1544            * created based on the previous version and metadata.
1545            *
1546            * @param fileEntryId the primary key of the file entry
1547            * @param version the version to revert back to
1548            * @param serviceContext the service context to be applied
1549            */
1550            public void revertFileEntry(long fileEntryId, java.lang.String version,
1551                    com.liferay.portal.service.ServiceContext serviceContext)
1552                    throws PortalException;
1553    
1554            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1555            public com.liferay.portal.kernel.search.Hits search(long repositoryId,
1556                    long creatorUserId, long folderId, java.lang.String[] mimeTypes,
1557                    int status, int start, int end) throws PortalException;
1558    
1559            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1560            public com.liferay.portal.kernel.search.Hits search(long repositoryId,
1561                    long creatorUserId, int status, int start, int end)
1562                    throws PortalException;
1563    
1564            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1565            public com.liferay.portal.kernel.search.Hits search(long repositoryId,
1566                    com.liferay.portal.kernel.search.SearchContext searchContext)
1567                    throws com.liferay.portal.kernel.search.SearchException;
1568    
1569            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1570            public com.liferay.portal.kernel.search.Hits search(long repositoryId,
1571                    com.liferay.portal.kernel.search.SearchContext searchContext,
1572                    com.liferay.portal.kernel.search.Query query)
1573                    throws com.liferay.portal.kernel.search.SearchException;
1574    
1575            /**
1576            * Subscribe the user to changes in documents of the file entry type. This
1577            * method is only supported by the Liferay repository.
1578            *
1579            * @param groupId the primary key of the file entry type's group
1580            * @param fileEntryTypeId the primary key of the file entry type
1581            */
1582            public void subscribeFileEntryType(long groupId, long fileEntryTypeId)
1583                    throws PortalException;
1584    
1585            /**
1586            * Subscribe the user to document changes in the folder. This method is only
1587            * supported by the Liferay repository.
1588            *
1589            * @param groupId the primary key of the folder's group
1590            * @param folderId the primary key of the folder
1591            */
1592            public void subscribeFolder(long groupId, long folderId)
1593                    throws PortalException;
1594    
1595            /**
1596            * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
1597            boolean, String, ServiceContext)}.
1598            */
1599            @java.lang.Deprecated
1600            public void unlockFileEntry(long fileEntryId) throws PortalException;
1601    
1602            /**
1603            * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
1604            String)}.
1605            */
1606            @java.lang.Deprecated
1607            public void unlockFileEntry(long fileEntryId, java.lang.String lockUuid)
1608                    throws PortalException;
1609    
1610            /**
1611            * Unlocks the folder. This method is primarily used by WebDAV.
1612            *
1613            * @param repositoryId the primary key of the repository
1614            * @param folderId the primary key of the folder
1615            * @param lockUuid the lock's UUID
1616            */
1617            public void unlockFolder(long repositoryId, long folderId,
1618                    java.lang.String lockUuid) throws PortalException;
1619    
1620            /**
1621            * Unlocks the folder. This method is primarily used by WebDAV.
1622            *
1623            * @param repositoryId the primary key of the repository
1624            * @param parentFolderId the primary key of the parent folder
1625            * @param name the folder's name
1626            * @param lockUuid the lock's UUID
1627            */
1628            public void unlockFolder(long repositoryId, long parentFolderId,
1629                    java.lang.String name, java.lang.String lockUuid)
1630                    throws PortalException;
1631    
1632            /**
1633            * Unsubscribe the user from changes in documents of the file entry type.
1634            * This method is only supported by the Liferay repository.
1635            *
1636            * @param groupId the primary key of the file entry type's group
1637            * @param fileEntryTypeId the primary key of the file entry type
1638            */
1639            public void unsubscribeFileEntryType(long groupId, long fileEntryTypeId)
1640                    throws PortalException;
1641    
1642            /**
1643            * Unsubscribe the user from document changes in the folder. This method is
1644            * only supported by the Liferay repository.
1645            *
1646            * @param groupId the primary key of the folder's group
1647            * @param folderId the primary key of the folder
1648            */
1649            public void unsubscribeFolder(long groupId, long folderId)
1650                    throws PortalException;
1651    
1652            /**
1653            * Updates a file entry and associated metadata based on a byte array
1654            * object. If the file data is <code>null</code>, then only the associated
1655            * metadata (i.e., <code>title</code>, <code>description</code>, and
1656            * parameters in the <code>serviceContext</code>) will be updated.
1657            *
1658            * <p>
1659            * This method takes two file names, the <code>sourceFileName</code> and the
1660            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
1661            * name of the actual file being uploaded. The <code>title</code>
1662            * corresponds to a name the client wishes to assign this file after it has
1663            * been uploaded to the portal.
1664            * </p>
1665            *
1666            * @param fileEntryId the primary key of the file entry
1667            * @param sourceFileName the original file's name (optionally
1668            <code>null</code>)
1669            * @param mimeType the file's MIME type (optionally <code>null</code>)
1670            * @param title the new name to be assigned to the file (optionally <code>
1671            <code>null</code></code>)
1672            * @param description the file's new description
1673            * @param changeLog the file's version change log (optionally
1674            <code>null</code>)
1675            * @param majorVersion whether the new file version is a major version
1676            * @param bytes the file's data (optionally <code>null</code>)
1677            * @param serviceContext the service context to be applied. Can set the
1678            asset category IDs, asset tag names, and expando bridge
1679            attributes for the file entry. In a Liferay repository, it may
1680            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
1681            type </li> <li> fieldsMap - mapping for fields associated with a
1682            custom file entry type </li> </ul>
1683            * @return the file entry
1684            */
1685            public com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
1686                    long fileEntryId, java.lang.String sourceFileName,
1687                    java.lang.String mimeType, java.lang.String title,
1688                    java.lang.String description, java.lang.String changeLog,
1689                    boolean majorVersion, byte[] bytes,
1690                    com.liferay.portal.service.ServiceContext serviceContext)
1691                    throws PortalException;
1692    
1693            /**
1694            * Updates a file entry and associated metadata based on a {@link File}
1695            * object. If the file data is <code>null</code>, then only the associated
1696            * metadata (i.e., <code>title</code>, <code>description</code>, and
1697            * parameters in the <code>serviceContext</code>) will be updated.
1698            *
1699            * <p>
1700            * This method takes two file names, the <code>sourceFileName</code> and the
1701            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
1702            * name of the actual file being uploaded. The <code>title</code>
1703            * corresponds to a name the client wishes to assign this file after it has
1704            * been uploaded to the portal.
1705            * </p>
1706            *
1707            * @param fileEntryId the primary key of the file entry
1708            * @param sourceFileName the original file's name (optionally
1709            <code>null</code>)
1710            * @param mimeType the file's MIME type (optionally <code>null</code>)
1711            * @param title the new name to be assigned to the file (optionally <code>
1712            <code>null</code></code>)
1713            * @param description the file's new description
1714            * @param changeLog the file's version change log (optionally
1715            <code>null</code>)
1716            * @param majorVersion whether the new file version is a major version
1717            * @param file the file's data (optionally <code>null</code>)
1718            * @param serviceContext the service context to be applied. Can set the
1719            asset category IDs, asset tag names, and expando bridge
1720            attributes for the file entry. In a Liferay repository, it may
1721            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
1722            type </li> <li> fieldsMap - mapping for fields associated with a
1723            custom file entry type </li> </ul>
1724            * @return the file entry
1725            */
1726            public com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
1727                    long fileEntryId, java.lang.String sourceFileName,
1728                    java.lang.String mimeType, java.lang.String title,
1729                    java.lang.String description, java.lang.String changeLog,
1730                    boolean majorVersion, java.io.File file,
1731                    com.liferay.portal.service.ServiceContext serviceContext)
1732                    throws PortalException;
1733    
1734            /**
1735            * Updates a file entry and associated metadata based on an {@link
1736            * InputStream} object. If the file data is <code>null</code>, then only the
1737            * associated metadata (i.e., <code>title</code>, <code>description</code>,
1738            * and parameters in the <code>serviceContext</code>) will be updated.
1739            *
1740            * <p>
1741            * This method takes two file names, the <code>sourceFileName</code> and the
1742            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
1743            * name of the actual file being uploaded. The <code>title</code>
1744            * corresponds to a name the client wishes to assign this file after it has
1745            * been uploaded to the portal.
1746            * </p>
1747            *
1748            * @param fileEntryId the primary key of the file entry
1749            * @param sourceFileName the original file's name (optionally
1750            <code>null</code>)
1751            * @param mimeType the file's MIME type (optionally <code>null</code>)
1752            * @param title the new name to be assigned to the file (optionally <code>
1753            <code>null</code></code>)
1754            * @param description the file's new description
1755            * @param changeLog the file's version change log (optionally
1756            <code>null</code>)
1757            * @param majorVersion whether the new file version is a major version
1758            * @param is the file's data (optionally <code>null</code>)
1759            * @param size the file's size (optionally <code>0</code>)
1760            * @param serviceContext the service context to be applied. Can set the
1761            asset category IDs, asset tag names, and expando bridge
1762            attributes for the file entry. In a Liferay repository, it may
1763            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
1764            type </li> <li> fieldsMap - mapping for fields associated with a
1765            custom file entry type </li> </ul>
1766            * @return the file entry
1767            */
1768            public com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
1769                    long fileEntryId, java.lang.String sourceFileName,
1770                    java.lang.String mimeType, java.lang.String title,
1771                    java.lang.String description, java.lang.String changeLog,
1772                    boolean majorVersion, java.io.InputStream is, long size,
1773                    com.liferay.portal.service.ServiceContext serviceContext)
1774                    throws PortalException;
1775    
1776            public com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
1777                    long fileEntryId, java.lang.String sourceFileName,
1778                    java.lang.String mimeType, java.lang.String title,
1779                    java.lang.String description, java.lang.String changeLog,
1780                    boolean majorVersion, java.io.File file,
1781                    com.liferay.portal.service.ServiceContext serviceContext)
1782                    throws PortalException;
1783    
1784            public com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
1785                    long fileEntryId, java.lang.String sourceFileName,
1786                    java.lang.String mimeType, java.lang.String title,
1787                    java.lang.String description, java.lang.String changeLog,
1788                    boolean majorVersion, java.io.InputStream is, long size,
1789                    com.liferay.portal.service.ServiceContext serviceContext)
1790                    throws PortalException;
1791    
1792            /**
1793            * Updates a file shortcut to the existing file entry. This method is only
1794            * supported by the Liferay repository.
1795            *
1796            * @param fileShortcutId the primary key of the file shortcut
1797            * @param folderId the primary key of the file shortcut's parent folder
1798            * @param toFileEntryId the primary key of the file shortcut's file entry
1799            * @param serviceContext the service context to be applied. Can set the
1800            asset category IDs, asset tag names, and expando bridge
1801            attributes for the file entry.
1802            * @return the file shortcut
1803            */
1804            public com.liferay.portal.kernel.repository.model.FileShortcut updateFileShortcut(
1805                    long fileShortcutId, long folderId, long toFileEntryId,
1806                    com.liferay.portal.service.ServiceContext serviceContext)
1807                    throws PortalException;
1808    
1809            /**
1810            * Updates the folder.
1811            *
1812            * @param folderId the primary key of the folder
1813            * @param name the folder's new name
1814            * @param description the folder's new description
1815            * @param serviceContext the service context to be applied. In a Liferay
1816            repository, it may include:  <ul> <li> defaultFileEntryTypeId -
1817            the file entry type to default all Liferay file entries to </li>
1818            <li> dlFileEntryTypesSearchContainerPrimaryKeys - a
1819            comma-delimited list of file entry type primary keys allowed in
1820            the given folder and all descendants </li> <li> restrictionType -
1821            specifying restriction type of file entry types allowed </li>
1822            <li> workflowDefinitionXYZ - the workflow definition name
1823            specified per file entry type. The parameter name must be the
1824            string <code>workflowDefinition</code> appended by the
1825            <code>fileEntryTypeId</code> (optionally <code>0</code>).</li>
1826            </ul>
1827            * @return the folder
1828            */
1829            public com.liferay.portal.kernel.repository.model.Folder updateFolder(
1830                    long folderId, java.lang.String name, java.lang.String description,
1831                    com.liferay.portal.service.ServiceContext serviceContext)
1832                    throws PortalException;
1833    
1834            /**
1835            * Returns <code>true</code> if the file entry is checked out. This method
1836            * is primarily used by WebDAV.
1837            *
1838            * @param repositoryId the primary key for the repository
1839            * @param fileEntryId the primary key for the file entry
1840            * @param lockUuid the lock's UUID
1841            * @return <code>true</code> if the file entry is checked out;
1842            <code>false</code> otherwise
1843            */
1844            public boolean verifyFileEntryCheckOut(long repositoryId, long fileEntryId,
1845                    java.lang.String lockUuid) throws PortalException;
1846    
1847            public boolean verifyFileEntryLock(long repositoryId, long fileEntryId,
1848                    java.lang.String lockUuid) throws PortalException;
1849    
1850            /**
1851            * Returns <code>true</code> if the inheritable lock exists. This method is
1852            * primarily used by WebDAV.
1853            *
1854            * @param repositoryId the primary key for the repository
1855            * @param folderId the primary key for the folder
1856            * @param lockUuid the lock's UUID
1857            * @return <code>true</code> if the inheritable lock exists;
1858            <code>false</code> otherwise
1859            */
1860            public boolean verifyInheritableLock(long repositoryId, long folderId,
1861                    java.lang.String lockUuid) throws PortalException;
1862    }