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