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