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            public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getFileEntries(
759                    long repositoryId, long folderId, java.lang.String[] mimeTypes)
760                    throws RemoteException {
761                    try {
762                            java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue =
763                                    DLAppServiceUtil.getFileEntries(repositoryId, folderId,
764                                            mimeTypes);
765    
766                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue);
767                    }
768                    catch (Exception e) {
769                            _log.error(e, e);
770    
771                            throw new RemoteException(e.getMessage());
772                    }
773            }
774    
775            /**
776            * Returns the number of file entries and shortcuts in the folder.
777            *
778            * @param repositoryId the primary key of the repository
779            * @param folderId the primary key of the folder
780            * @param status the workflow status
781            * @return the number of file entries and shortcuts in the folder
782            * @throws PortalException if the folder ould not be found
783            * @throws SystemException if a system exception occurred
784            */
785            public static int getFileEntriesAndFileShortcutsCount(long repositoryId,
786                    long folderId, int status) throws RemoteException {
787                    try {
788                            int returnValue = DLAppServiceUtil.getFileEntriesAndFileShortcutsCount(repositoryId,
789                                            folderId, status);
790    
791                            return returnValue;
792                    }
793                    catch (Exception e) {
794                            _log.error(e, e);
795    
796                            throw new RemoteException(e.getMessage());
797                    }
798            }
799    
800            /**
801            * Returns the number of file entries and shortcuts in the folder.
802            *
803            * @param repositoryId the primary key of the repository
804            * @param folderId the primary key of the folder
805            * @param status the workflow status
806            * @param mimeTypes allowed media types
807            * @return the number of file entries and shortcuts in the folder
808            * @throws PortalException if the folder ould not be found
809            * @throws SystemException if a system exception occurred
810            */
811            public static int getFileEntriesAndFileShortcutsCount(long repositoryId,
812                    long folderId, int status, java.lang.String[] mimeTypes)
813                    throws RemoteException {
814                    try {
815                            int returnValue = DLAppServiceUtil.getFileEntriesAndFileShortcutsCount(repositoryId,
816                                            folderId, status, mimeTypes);
817    
818                            return returnValue;
819                    }
820                    catch (Exception e) {
821                            _log.error(e, e);
822    
823                            throw new RemoteException(e.getMessage());
824                    }
825            }
826    
827            /**
828            * Returns the number of file entries in the folder.
829            *
830            * @param repositoryId the primary key of the file entry's repository
831            * @param folderId the primary key of the file entry's folder
832            * @return the number of file entries in the folder
833            * @throws PortalException if the folder could not be found
834            * @throws SystemException if a system exception occurred
835            */
836            public static int getFileEntriesCount(long repositoryId, long folderId)
837                    throws RemoteException {
838                    try {
839                            int returnValue = DLAppServiceUtil.getFileEntriesCount(repositoryId,
840                                            folderId);
841    
842                            return returnValue;
843                    }
844                    catch (Exception e) {
845                            _log.error(e, e);
846    
847                            throw new RemoteException(e.getMessage());
848                    }
849            }
850    
851            /**
852            * Returns the number of file entries with the file entry type in the
853            * folder.
854            *
855            * @param repositoryId the primary key of the file entry's repository
856            * @param folderId the primary key of the file entry's folder
857            * @param fileEntryTypeId the primary key of the file entry type
858            * @return the number of file entries with the file entry type in the folder
859            * @throws PortalException if the folder could not be found
860            * @throws SystemException if a system exception occurred
861            */
862            public static int getFileEntriesCount(long repositoryId, long folderId,
863                    long fileEntryTypeId) throws RemoteException {
864                    try {
865                            int returnValue = DLAppServiceUtil.getFileEntriesCount(repositoryId,
866                                            folderId, fileEntryTypeId);
867    
868                            return returnValue;
869                    }
870                    catch (Exception e) {
871                            _log.error(e, e);
872    
873                            throw new RemoteException(e.getMessage());
874                    }
875            }
876    
877            /**
878            * Returns the file entry with the primary key.
879            *
880            * @param fileEntryId the primary key of the file entry
881            * @return the file entry with the primary key
882            * @throws PortalException if the file entry could not be found
883            * @throws SystemException if a system exception occurred
884            */
885            public static com.liferay.portal.kernel.repository.model.FileEntrySoap getFileEntry(
886                    long fileEntryId) throws RemoteException {
887                    try {
888                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.getFileEntry(fileEntryId);
889    
890                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
891                    }
892                    catch (Exception e) {
893                            _log.error(e, e);
894    
895                            throw new RemoteException(e.getMessage());
896                    }
897            }
898    
899            /**
900            * Returns the file entry with the title in the folder.
901            *
902            * @param groupId the primary key of the file entry's group
903            * @param folderId the primary key of the file entry's folder
904            * @param title the file entry's title
905            * @return the file entry with the title in the folder
906            * @throws PortalException if the file entry could not be found
907            * @throws SystemException if a system exception occurred
908            */
909            public static com.liferay.portal.kernel.repository.model.FileEntrySoap getFileEntry(
910                    long groupId, long folderId, java.lang.String title)
911                    throws RemoteException {
912                    try {
913                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.getFileEntry(groupId,
914                                            folderId, title);
915    
916                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
917                    }
918                    catch (Exception e) {
919                            _log.error(e, e);
920    
921                            throw new RemoteException(e.getMessage());
922                    }
923            }
924    
925            /**
926            * Returns the file entry with the UUID and group.
927            *
928            * @param uuid the file entry's UUID
929            * @param groupId the primary key of the file entry's group
930            * @return the file entry with the UUID and group
931            * @throws PortalException if the file entry could not be found
932            * @throws SystemException if a system exception occurred
933            */
934            public static com.liferay.portal.kernel.repository.model.FileEntrySoap getFileEntryByUuidAndGroupId(
935                    java.lang.String uuid, long groupId) throws RemoteException {
936                    try {
937                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.getFileEntryByUuidAndGroupId(uuid,
938                                            groupId);
939    
940                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
941                    }
942                    catch (Exception e) {
943                            _log.error(e, e);
944    
945                            throw new RemoteException(e.getMessage());
946                    }
947            }
948    
949            /**
950            * Returns the file shortcut with the primary key. This method is only
951            * supported by the Liferay repository.
952            *
953            * @param fileShortcutId the primary key of the file shortcut
954            * @return the file shortcut with the primary key
955            * @throws PortalException if the file shortcut could not be found
956            * @throws SystemException if a system exception occurred
957            */
958            public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap getFileShortcut(
959                    long fileShortcutId) throws RemoteException {
960                    try {
961                            com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue =
962                                    DLAppServiceUtil.getFileShortcut(fileShortcutId);
963    
964                            return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue);
965                    }
966                    catch (Exception e) {
967                            _log.error(e, e);
968    
969                            throw new RemoteException(e.getMessage());
970                    }
971            }
972    
973            /**
974            * Returns the folder with the primary key.
975            *
976            * @param folderId the primary key of the folder
977            * @return the folder with the primary key
978            * @throws PortalException if the folder could not be found
979            * @throws SystemException if a system exception occurred
980            */
981            public static com.liferay.portal.kernel.repository.model.FolderSoap getFolder(
982                    long folderId) throws RemoteException {
983                    try {
984                            com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.getFolder(folderId);
985    
986                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue);
987                    }
988                    catch (Exception e) {
989                            _log.error(e, e);
990    
991                            throw new RemoteException(e.getMessage());
992                    }
993            }
994    
995            /**
996            * Returns the folder with the name in the parent folder.
997            *
998            * @param repositoryId the primary key of the folder's repository
999            * @param parentFolderId the primary key of the folder's parent folder
1000            * @param name the folder's name
1001            * @return the folder with the name in the parent folder
1002            * @throws PortalException if the folder could not be found
1003            * @throws SystemException if a system exception occurred
1004            */
1005            public static com.liferay.portal.kernel.repository.model.FolderSoap getFolder(
1006                    long repositoryId, long parentFolderId, java.lang.String name)
1007                    throws RemoteException {
1008                    try {
1009                            com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.getFolder(repositoryId,
1010                                            parentFolderId, name);
1011    
1012                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue);
1013                    }
1014                    catch (Exception e) {
1015                            _log.error(e, e);
1016    
1017                            throw new RemoteException(e.getMessage());
1018                    }
1019            }
1020    
1021            /**
1022            * Returns all immediate subfolders of the parent folder.
1023            *
1024            * @param repositoryId the primary key of the folder's repository
1025            * @param parentFolderId the primary key of the folder's parent folder
1026            * @return the immediate subfolders of the parent folder
1027            * @throws PortalException if the parent folder could not be found
1028            * @throws SystemException if a system exception occurred
1029            */
1030            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1031                    long repositoryId, long parentFolderId) throws RemoteException {
1032                    try {
1033                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1034                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId);
1035    
1036                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1037                    }
1038                    catch (Exception e) {
1039                            _log.error(e, e);
1040    
1041                            throw new RemoteException(e.getMessage());
1042                    }
1043            }
1044    
1045            /**
1046            * Returns all immediate subfolders of the parent folder, optionally
1047            * including mount folders for third-party repositories.
1048            *
1049            * @param repositoryId the primary key of the folder's repository
1050            * @param parentFolderId the primary key of the folder's parent folder
1051            * @param includeMountFolders whether to include mount folders for
1052            third-party repositories
1053            * @return the immediate subfolders of the parent folder
1054            * @throws PortalException if the parent folder could not be found
1055            * @throws SystemException if a system exception occurred
1056            */
1057            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1058                    long repositoryId, long parentFolderId, boolean includeMountFolders)
1059                    throws RemoteException {
1060                    try {
1061                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1062                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId,
1063                                            includeMountFolders);
1064    
1065                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1066                    }
1067                    catch (Exception e) {
1068                            _log.error(e, e);
1069    
1070                            throw new RemoteException(e.getMessage());
1071                    }
1072            }
1073    
1074            /**
1075            * Returns a range of all the immediate subfolders of the parent folder,
1076            * optionally including mount folders for third-party repositories.
1077            *
1078            * <p>
1079            * Useful when paginating results. Returns a maximum of <code>end -
1080            * start</code> instances. <code>start</code> and <code>end</code> are not
1081            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1082            * refers to the first result in the set. Setting both <code>start</code>
1083            * and <code>end</code> to {@link
1084            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1085            * result set.
1086            * </p>
1087            *
1088            * @param repositoryId the primary key of the folder's repository
1089            * @param parentFolderId the primary key of the folder's parent folder
1090            * @param includeMountFolders whether to include mount folders for
1091            third-party repositories
1092            * @param start the lower bound of the range of results
1093            * @param end the upper bound of the range of results (not inclusive)
1094            * @return the range of immediate subfolders of the parent folder
1095            * @throws PortalException if the parent folder could not be found
1096            * @throws SystemException if a system exception occurred
1097            */
1098            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1099                    long repositoryId, long parentFolderId, boolean includeMountFolders,
1100                    int start, int end) throws RemoteException {
1101                    try {
1102                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1103                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId,
1104                                            includeMountFolders, start, end);
1105    
1106                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1107                    }
1108                    catch (Exception e) {
1109                            _log.error(e, e);
1110    
1111                            throw new RemoteException(e.getMessage());
1112                    }
1113            }
1114    
1115            /**
1116            * Returns an ordered range of all the immediate subfolders of the parent
1117            * folder.
1118            *
1119            * <p>
1120            * Useful when paginating results. Returns a maximum of <code>end -
1121            * start</code> instances. <code>start</code> and <code>end</code> are not
1122            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1123            * refers to the first result in the set. Setting both <code>start</code>
1124            * and <code>end</code> to {@link
1125            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1126            * result set.
1127            * </p>
1128            *
1129            * @param repositoryId the primary key of the folder's repository
1130            * @param parentFolderId the primary key of the folder's parent folder
1131            * @param includeMountFolders whether to include mount folders for
1132            third-party repositories
1133            * @param start the lower bound of the range of results
1134            * @param end the upper bound of the range of results (not inclusive)
1135            * @param obc the comparator to order the folders (optionally
1136            <code>null</code>)
1137            * @return the range of immediate subfolders of the parent folder ordered by
1138            comparator <code>obc</code>
1139            * @throws PortalException if the parent folder could not be found
1140            * @throws SystemException if a system exception occurred
1141            */
1142            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1143                    long repositoryId, long parentFolderId, boolean includeMountFolders,
1144                    int start, int end, com.liferay.portal.kernel.util.OrderByComparator obc)
1145                    throws RemoteException {
1146                    try {
1147                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1148                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId,
1149                                            includeMountFolders, start, end, obc);
1150    
1151                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1152                    }
1153                    catch (Exception e) {
1154                            _log.error(e, e);
1155    
1156                            throw new RemoteException(e.getMessage());
1157                    }
1158            }
1159    
1160            /**
1161            * Returns an ordered range of all the immediate subfolders of the parent
1162            * folder.
1163            *
1164            * <p>
1165            * Useful when paginating results. Returns a maximum of <code>end -
1166            * start</code> instances. <code>start</code> and <code>end</code> are not
1167            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1168            * refers to the first result in the set. Setting both <code>start</code>
1169            * and <code>end</code> to {@link
1170            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1171            * result set.
1172            * </p>
1173            *
1174            * @param repositoryId the primary key of the folder's repository
1175            * @param parentFolderId the primary key of the folder's parent folder
1176            * @param status the workflow status
1177            * @param includeMountFolders whether to include mount folders for
1178            third-party repositories
1179            * @param start the lower bound of the range of results
1180            * @param end the upper bound of the range of results (not inclusive)
1181            * @param obc the comparator to order the folders (optionally
1182            <code>null</code>)
1183            * @return the range of immediate subfolders of the parent folder ordered by
1184            comparator <code>obc</code>
1185            * @throws PortalException if the parent folder could not be found
1186            * @throws SystemException if a system exception occurred
1187            */
1188            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1189                    long repositoryId, long parentFolderId, int status,
1190                    boolean includeMountFolders, int start, int end,
1191                    com.liferay.portal.kernel.util.OrderByComparator obc)
1192                    throws RemoteException {
1193                    try {
1194                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1195                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId,
1196                                            status, includeMountFolders, start, end, obc);
1197    
1198                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1199                    }
1200                    catch (Exception e) {
1201                            _log.error(e, e);
1202    
1203                            throw new RemoteException(e.getMessage());
1204                    }
1205            }
1206    
1207            /**
1208            * Returns a range of all the immediate subfolders of the parent folder.
1209            *
1210            * <p>
1211            * Useful when paginating results. Returns a maximum of <code>end -
1212            * start</code> instances. <code>start</code> and <code>end</code> are not
1213            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1214            * refers to the first result in the set. Setting both <code>start</code>
1215            * and <code>end</code> to {@link
1216            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1217            * result set.
1218            * </p>
1219            *
1220            * @param repositoryId the primary key of the folder's repository
1221            * @param parentFolderId the primary key of the folder's parent folder
1222            * @param start the lower bound of the range of results
1223            * @param end the upper bound of the range of results (not inclusive)
1224            * @return the range of immediate subfolders of the parent folder
1225            * @throws PortalException if the parent folder could not be found
1226            * @throws SystemException if a system exception occurred
1227            */
1228            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1229                    long repositoryId, long parentFolderId, int start, int end)
1230                    throws RemoteException {
1231                    try {
1232                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1233                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId,
1234                                            start, end);
1235    
1236                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1237                    }
1238                    catch (Exception e) {
1239                            _log.error(e, e);
1240    
1241                            throw new RemoteException(e.getMessage());
1242                    }
1243            }
1244    
1245            /**
1246            * Returns an ordered range of all the immediate subfolders of the parent
1247            * folder.
1248            *
1249            * <p>
1250            * Useful when paginating results. Returns a maximum of <code>end -
1251            * start</code> instances. <code>start</code> and <code>end</code> are not
1252            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1253            * refers to the first result in the set. Setting both <code>start</code>
1254            * and <code>end</code> to {@link
1255            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1256            * result set.
1257            * </p>
1258            *
1259            * @param repositoryId the primary key of the folder's repository
1260            * @param parentFolderId the primary key of the folder's parent folder
1261            * @param start the lower bound of the range of results
1262            * @param end the upper bound of the range of results (not inclusive)
1263            * @param obc the comparator to order the folders (optionally
1264            <code>null</code>)
1265            * @return the range of immediate subfolders of the parent folder ordered by
1266            comparator <code>obc</code>
1267            * @throws PortalException if the parent folder could not be found
1268            * @throws SystemException if a system exception occurred
1269            */
1270            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getFolders(
1271                    long repositoryId, long parentFolderId, int start, int end,
1272                    com.liferay.portal.kernel.util.OrderByComparator obc)
1273                    throws RemoteException {
1274                    try {
1275                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1276                                    DLAppServiceUtil.getFolders(repositoryId, parentFolderId,
1277                                            start, end, obc);
1278    
1279                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1280                    }
1281                    catch (Exception e) {
1282                            _log.error(e, e);
1283    
1284                            throw new RemoteException(e.getMessage());
1285                    }
1286            }
1287    
1288            /**
1289            * Returns the number of immediate subfolders, file entries, and file
1290            * shortcuts in the parent folder.
1291            *
1292            * @param repositoryId the primary key of the repository
1293            * @param folderId the primary key of the parent folder
1294            * @param status the workflow status
1295            * @param includeMountFolders whether to include mount folders for
1296            third-party repositories
1297            * @return the number of immediate subfolders, file entries, and file
1298            shortcuts in the parent folder
1299            * @throws PortalException if the folder could not be found
1300            * @throws SystemException if a system exception occurred
1301            */
1302            public static int getFoldersAndFileEntriesAndFileShortcutsCount(
1303                    long repositoryId, long folderId, int status,
1304                    boolean includeMountFolders) throws RemoteException {
1305                    try {
1306                            int returnValue = DLAppServiceUtil.getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId,
1307                                            folderId, status, 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            public static int getFoldersAndFileEntriesAndFileShortcutsCount(
1319                    long repositoryId, long folderId, int status,
1320                    java.lang.String[] mimeTypes, boolean includeMountFolders)
1321                    throws RemoteException {
1322                    try {
1323                            int returnValue = DLAppServiceUtil.getFoldersAndFileEntriesAndFileShortcutsCount(repositoryId,
1324                                            folderId, status, mimeTypes, includeMountFolders);
1325    
1326                            return returnValue;
1327                    }
1328                    catch (Exception e) {
1329                            _log.error(e, e);
1330    
1331                            throw new RemoteException(e.getMessage());
1332                    }
1333            }
1334    
1335            /**
1336            * Returns the number of immediate subfolders of the parent folder.
1337            *
1338            * @param repositoryId the primary key of the folder's repository
1339            * @param parentFolderId the primary key of the folder's parent folder
1340            * @return the number of immediate subfolders of the parent folder
1341            * @throws PortalException if the parent folder could not be found
1342            * @throws SystemException if a system exception occurred
1343            */
1344            public static int getFoldersCount(long repositoryId, long parentFolderId)
1345                    throws RemoteException {
1346                    try {
1347                            int returnValue = DLAppServiceUtil.getFoldersCount(repositoryId,
1348                                            parentFolderId);
1349    
1350                            return returnValue;
1351                    }
1352                    catch (Exception e) {
1353                            _log.error(e, e);
1354    
1355                            throw new RemoteException(e.getMessage());
1356                    }
1357            }
1358    
1359            /**
1360            * Returns the number of immediate subfolders of the parent folder,
1361            * optionally including mount folders for third-party repositories.
1362            *
1363            * @param repositoryId the primary key of the folder's repository
1364            * @param parentFolderId the primary key of the folder's parent folder
1365            * @param includeMountFolders whether to include mount folders for
1366            third-party repositories
1367            * @return the number of immediate subfolders of the parent folder
1368            * @throws PortalException if the parent folder could not be found
1369            * @throws SystemException if a system exception occurred
1370            */
1371            public static int getFoldersCount(long repositoryId, long parentFolderId,
1372                    boolean includeMountFolders) throws RemoteException {
1373                    try {
1374                            int returnValue = DLAppServiceUtil.getFoldersCount(repositoryId,
1375                                            parentFolderId, includeMountFolders);
1376    
1377                            return returnValue;
1378                    }
1379                    catch (Exception e) {
1380                            _log.error(e, e);
1381    
1382                            throw new RemoteException(e.getMessage());
1383                    }
1384            }
1385    
1386            /**
1387            * Returns the number of immediate subfolders of the parent folder,
1388            * optionally including mount folders for third-party repositories.
1389            *
1390            * @param repositoryId the primary key of the folder's repository
1391            * @param parentFolderId the primary key of the folder's parent folder
1392            * @param status the workflow status
1393            * @param includeMountFolders whether to include mount folders for
1394            third-party repositories
1395            * @return the number of immediate subfolders of the parent folder
1396            * @throws PortalException if the parent folder could not be found
1397            * @throws SystemException if a system exception occurred
1398            */
1399            public static int getFoldersCount(long repositoryId, long parentFolderId,
1400                    int status, boolean includeMountFolders) throws RemoteException {
1401                    try {
1402                            int returnValue = DLAppServiceUtil.getFoldersCount(repositoryId,
1403                                            parentFolderId, status, includeMountFolders);
1404    
1405                            return returnValue;
1406                    }
1407                    catch (Exception e) {
1408                            _log.error(e, e);
1409    
1410                            throw new RemoteException(e.getMessage());
1411                    }
1412            }
1413    
1414            /**
1415            * Returns the number of immediate subfolders and file entries across the
1416            * folders.
1417            *
1418            * @param repositoryId the primary key of the repository
1419            * @param folderIds the primary keys of folders from which to count
1420            immediate subfolders and file entries
1421            * @param status the workflow status
1422            * @return the number of immediate subfolders and file entries across the
1423            folders
1424            * @throws PortalException if the repository could not be found
1425            * @throws SystemException if a system exception occurred
1426            */
1427            public static int getFoldersFileEntriesCount(long repositoryId,
1428                    Long[] folderIds, int status) throws RemoteException {
1429                    try {
1430                            int returnValue = DLAppServiceUtil.getFoldersFileEntriesCount(repositoryId,
1431                                            ListUtil.toList(folderIds), status);
1432    
1433                            return returnValue;
1434                    }
1435                    catch (Exception e) {
1436                            _log.error(e, e);
1437    
1438                            throw new RemoteException(e.getMessage());
1439                    }
1440            }
1441    
1442            /**
1443            * Returns an ordered range of all the file entries in the group starting at
1444            * the repository default parent folder that are stored within the Liferay
1445            * repository. This method is primarily used to search for recently modified
1446            * file entries. It can be limited to the file entries modified by a given
1447            * user.
1448            *
1449            * <p>
1450            * Useful when paginating results. Returns a maximum of <code>end -
1451            * start</code> instances. <code>start</code> and <code>end</code> are not
1452            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1453            * refers to the first result in the set. Setting both <code>start</code>
1454            * and <code>end</code> to {@link
1455            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1456            * result set.
1457            * </p>
1458            *
1459            * @param groupId the primary key of the group
1460            * @param userId the primary key of the user who created the file
1461            (optionally <code>0</code>)
1462            * @param start the lower bound of the range of results
1463            * @param end the upper bound of the range of results (not inclusive)
1464            * @return the range of matching file entries ordered by date modified
1465            * @throws PortalException if the group could not be found
1466            * @throws SystemException if a system exception occurred
1467            */
1468            public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries(
1469                    long groupId, long userId, int start, int end)
1470                    throws RemoteException {
1471                    try {
1472                            java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue =
1473                                    DLAppServiceUtil.getGroupFileEntries(groupId, userId, start, end);
1474    
1475                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue);
1476                    }
1477                    catch (Exception e) {
1478                            _log.error(e, e);
1479    
1480                            throw new RemoteException(e.getMessage());
1481                    }
1482            }
1483    
1484            /**
1485            * Returns an ordered range of all the file entries in the group that are
1486            * stored within the Liferay repository. This method is primarily used to
1487            * search for recently modified file entries. It can be limited to the file
1488            * entries modified by a given user.
1489            *
1490            * <p>
1491            * Useful when paginating results. Returns a maximum of <code>end -
1492            * start</code> instances. <code>start</code> and <code>end</code> are not
1493            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1494            * refers to the first result in the set. Setting both <code>start</code>
1495            * and <code>end</code> to {@link
1496            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1497            * result set.
1498            * </p>
1499            *
1500            * @param groupId the primary key of the group
1501            * @param userId the primary key of the user who created the file
1502            (optionally <code>0</code>)
1503            * @param start the lower bound of the range of results
1504            * @param end the upper bound of the range of results (not inclusive)
1505            * @param obc the comparator to order the file entries (optionally
1506            <code>null</code>)
1507            * @return the range of matching file entries ordered by comparator
1508            <code>obc</code>
1509            * @throws PortalException if the group could not be found
1510            * @throws SystemException if a system exception occurred
1511            */
1512            public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries(
1513                    long groupId, long userId, int start, int end,
1514                    com.liferay.portal.kernel.util.OrderByComparator obc)
1515                    throws RemoteException {
1516                    try {
1517                            java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue =
1518                                    DLAppServiceUtil.getGroupFileEntries(groupId, userId, start,
1519                                            end, obc);
1520    
1521                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue);
1522                    }
1523                    catch (Exception e) {
1524                            _log.error(e, e);
1525    
1526                            throw new RemoteException(e.getMessage());
1527                    }
1528            }
1529    
1530            /**
1531            * Returns an ordered range of all the file entries in the group starting at
1532            * the root folder that are stored within the Liferay repository. This
1533            * method is primarily used to search for recently modified file entries. It
1534            * can be limited to the file entries modified by a given user.
1535            *
1536            * <p>
1537            * Useful when paginating results. Returns a maximum of <code>end -
1538            * start</code> instances. <code>start</code> and <code>end</code> are not
1539            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1540            * refers to the first result in the set. Setting both <code>start</code>
1541            * and <code>end</code> to {@link
1542            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1543            * result set.
1544            * </p>
1545            *
1546            * @param groupId the primary key of the group
1547            * @param userId the primary key of the user who created the file
1548            (optionally <code>0</code>)
1549            * @param rootFolderId the primary key of the root folder to begin the
1550            search
1551            * @param start the lower bound of the range of results
1552            * @param end the upper bound of the range of results (not inclusive)
1553            * @return the range of matching file entries ordered by date modified
1554            * @throws PortalException if the group could not be found
1555            * @throws SystemException if a system exception occurred
1556            */
1557            public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries(
1558                    long groupId, long userId, long rootFolderId, int start, int end)
1559                    throws RemoteException {
1560                    try {
1561                            java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue =
1562                                    DLAppServiceUtil.getGroupFileEntries(groupId, userId,
1563                                            rootFolderId, start, end);
1564    
1565                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue);
1566                    }
1567                    catch (Exception e) {
1568                            _log.error(e, e);
1569    
1570                            throw new RemoteException(e.getMessage());
1571                    }
1572            }
1573    
1574            /**
1575            * Returns an ordered range of all the file entries in the group starting at
1576            * the root folder that are stored within the Liferay repository. This
1577            * method is primarily used to search for recently modified file entries. It
1578            * can be limited to the file entries modified by a given user.
1579            *
1580            * <p>
1581            * Useful when paginating results. Returns a maximum of <code>end -
1582            * start</code> instances. <code>start</code> and <code>end</code> are not
1583            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1584            * refers to the first result in the set. Setting both <code>start</code>
1585            * and <code>end</code> to {@link
1586            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1587            * result set.
1588            * </p>
1589            *
1590            * @param groupId the primary key of the group
1591            * @param userId the primary key of the user who created the file
1592            (optionally <code>0</code>)
1593            * @param rootFolderId the primary key of the root folder to begin the
1594            search
1595            * @param start the lower bound of the range of results
1596            * @param end the upper bound of the range of results (not inclusive)
1597            * @param obc the comparator to order the file entries (optionally
1598            <code>null</code>)
1599            * @return the range of matching file entries ordered by comparator
1600            <code>obc</code>
1601            * @throws PortalException if the group could not be found
1602            * @throws SystemException if a system exception occurred
1603            */
1604            public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries(
1605                    long groupId, long userId, long rootFolderId, int start, int end,
1606                    com.liferay.portal.kernel.util.OrderByComparator obc)
1607                    throws RemoteException {
1608                    try {
1609                            java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue =
1610                                    DLAppServiceUtil.getGroupFileEntries(groupId, userId,
1611                                            rootFolderId, start, end, obc);
1612    
1613                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue);
1614                    }
1615                    catch (Exception e) {
1616                            _log.error(e, e);
1617    
1618                            throw new RemoteException(e.getMessage());
1619                    }
1620            }
1621    
1622            public static com.liferay.portal.kernel.repository.model.FileEntrySoap[] getGroupFileEntries(
1623                    long groupId, long userId, long rootFolderId,
1624                    java.lang.String[] mimeTypes, int status, int start, int end,
1625                    com.liferay.portal.kernel.util.OrderByComparator obc)
1626                    throws RemoteException {
1627                    try {
1628                            java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> returnValue =
1629                                    DLAppServiceUtil.getGroupFileEntries(groupId, userId,
1630                                            rootFolderId, mimeTypes, status, start, end, obc);
1631    
1632                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModels(returnValue);
1633                    }
1634                    catch (Exception e) {
1635                            _log.error(e, e);
1636    
1637                            throw new RemoteException(e.getMessage());
1638                    }
1639            }
1640    
1641            /**
1642            * Returns the number of file entries in a group starting at the repository
1643            * default parent folder that are stored within the Liferay repository. This
1644            * method is primarily used to search for recently modified file entries. It
1645            * can be limited to the file entries modified by a given user.
1646            *
1647            * @param groupId the primary key of the group
1648            * @param userId the primary key of the user who created the file
1649            (optionally <code>0</code>)
1650            * @return the number of matching file entries
1651            * @throws PortalException if the group could not be found
1652            * @throws SystemException if a system exception occurred
1653            */
1654            public static int getGroupFileEntriesCount(long groupId, long userId)
1655                    throws RemoteException {
1656                    try {
1657                            int returnValue = DLAppServiceUtil.getGroupFileEntriesCount(groupId,
1658                                            userId);
1659    
1660                            return returnValue;
1661                    }
1662                    catch (Exception e) {
1663                            _log.error(e, e);
1664    
1665                            throw new RemoteException(e.getMessage());
1666                    }
1667            }
1668    
1669            /**
1670            * Returns the number of file entries in a group starting at the root folder
1671            * that are stored within the Liferay repository. This method is primarily
1672            * used to search for recently modified file entries. It can be limited to
1673            * the file entries modified by a given user.
1674            *
1675            * @param groupId the primary key of the group
1676            * @param userId the primary key of the user who created the file
1677            (optionally <code>0</code>)
1678            * @param rootFolderId the primary key of the root folder to begin the
1679            search
1680            * @return the number of matching file entries
1681            * @throws PortalException if the group could not be found
1682            * @throws SystemException if a system exception occurred
1683            */
1684            public static int getGroupFileEntriesCount(long groupId, long userId,
1685                    long rootFolderId) throws RemoteException {
1686                    try {
1687                            int returnValue = DLAppServiceUtil.getGroupFileEntriesCount(groupId,
1688                                            userId, rootFolderId);
1689    
1690                            return returnValue;
1691                    }
1692                    catch (Exception e) {
1693                            _log.error(e, e);
1694    
1695                            throw new RemoteException(e.getMessage());
1696                    }
1697            }
1698    
1699            public static int getGroupFileEntriesCount(long groupId, long userId,
1700                    long rootFolderId, java.lang.String[] mimeTypes, int status)
1701                    throws RemoteException {
1702                    try {
1703                            int returnValue = DLAppServiceUtil.getGroupFileEntriesCount(groupId,
1704                                            userId, rootFolderId, mimeTypes, status);
1705    
1706                            return returnValue;
1707                    }
1708                    catch (Exception e) {
1709                            _log.error(e, e);
1710    
1711                            throw new RemoteException(e.getMessage());
1712                    }
1713            }
1714    
1715            /**
1716            * Returns all immediate subfolders of the parent folder that are used for
1717            * mounting third-party repositories. This method is only supported by the
1718            * Liferay repository.
1719            *
1720            * @param repositoryId the primary key of the folder's repository
1721            * @param parentFolderId the primary key of the folder's parent folder
1722            * @return the immediate subfolders of the parent folder that are used for
1723            mounting third-party repositories
1724            * @throws PortalException if the repository or parent folder could not be
1725            found
1726            * @throws SystemException if a system exception occurred
1727            */
1728            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getMountFolders(
1729                    long repositoryId, long parentFolderId) throws RemoteException {
1730                    try {
1731                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1732                                    DLAppServiceUtil.getMountFolders(repositoryId, parentFolderId);
1733    
1734                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1735                    }
1736                    catch (Exception e) {
1737                            _log.error(e, e);
1738    
1739                            throw new RemoteException(e.getMessage());
1740                    }
1741            }
1742    
1743            /**
1744            * Returns a range of all the immediate subfolders of the parent folder that
1745            * are used for mounting third-party repositories. This method is only
1746            * supported by the Liferay repository.
1747            *
1748            * <p>
1749            * Useful when paginating results. Returns a maximum of <code>end -
1750            * start</code> instances. <code>start</code> and <code>end</code> are not
1751            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1752            * refers to the first result in the set. Setting both <code>start</code>
1753            * and <code>end</code> to {@link
1754            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1755            * result set.
1756            * </p>
1757            *
1758            * @param repositoryId the primary key of the repository
1759            * @param parentFolderId the primary key of the parent folder
1760            * @param start the lower bound of the range of results
1761            * @param end the upper bound of the range of results (not inclusive)
1762            * @return the range of immediate subfolders of the parent folder that are
1763            used for mounting third-party repositories
1764            * @throws PortalException if the repository or parent folder could not be
1765            found
1766            * @throws SystemException if a system exception occurred
1767            */
1768            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getMountFolders(
1769                    long repositoryId, long parentFolderId, int start, int end)
1770                    throws RemoteException {
1771                    try {
1772                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1773                                    DLAppServiceUtil.getMountFolders(repositoryId, parentFolderId,
1774                                            start, end);
1775    
1776                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1777                    }
1778                    catch (Exception e) {
1779                            _log.error(e, e);
1780    
1781                            throw new RemoteException(e.getMessage());
1782                    }
1783            }
1784    
1785            /**
1786            * Returns an ordered range of all the immediate subfolders of the parent
1787            * folder that are used for mounting third-party repositories. This method
1788            * is only supported by the Liferay repository.
1789            *
1790            * <p>
1791            * Useful when paginating results. Returns a maximum of <code>end -
1792            * start</code> instances. <code>start</code> and <code>end</code> are not
1793            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1794            * refers to the first result in the set. Setting both <code>start</code>
1795            * and <code>end</code> to {@link
1796            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1797            * result set.
1798            * </p>
1799            *
1800            * @param repositoryId the primary key of the folder's repository
1801            * @param parentFolderId the primary key of the folder's parent folder
1802            * @param start the lower bound of the range of results
1803            * @param end the upper bound of the range of results (not inclusive)
1804            * @param obc the comparator to order the folders (optionally
1805            <code>null</code>)
1806            * @return the range of immediate subfolders of the parent folder that are
1807            used for mounting third-party repositories ordered by comparator
1808            <code>obc</code>
1809            * @throws PortalException if the repository or parent folder could not be
1810            found
1811            * @throws SystemException if a system exception occurred
1812            */
1813            public static com.liferay.portal.kernel.repository.model.FolderSoap[] getMountFolders(
1814                    long repositoryId, long parentFolderId, int start, int end,
1815                    com.liferay.portal.kernel.util.OrderByComparator obc)
1816                    throws RemoteException {
1817                    try {
1818                            java.util.List<com.liferay.portal.kernel.repository.model.Folder> returnValue =
1819                                    DLAppServiceUtil.getMountFolders(repositoryId, parentFolderId,
1820                                            start, end, obc);
1821    
1822                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModels(returnValue);
1823                    }
1824                    catch (Exception e) {
1825                            _log.error(e, e);
1826    
1827                            throw new RemoteException(e.getMessage());
1828                    }
1829            }
1830    
1831            /**
1832            * Returns the number of immediate subfolders of the parent folder that are
1833            * used for mounting third-party repositories. This method is only supported
1834            * by the Liferay repository.
1835            *
1836            * @param repositoryId the primary key of the repository
1837            * @param parentFolderId the primary key of the parent folder
1838            * @return the number of folders of the parent folder that are used for
1839            mounting third-party repositories
1840            * @throws PortalException if the repository or parent folder could not be
1841            found
1842            * @throws SystemException if a system exception occurred
1843            */
1844            public static int getMountFoldersCount(long repositoryId,
1845                    long parentFolderId) throws RemoteException {
1846                    try {
1847                            int returnValue = DLAppServiceUtil.getMountFoldersCount(repositoryId,
1848                                            parentFolderId);
1849    
1850                            return returnValue;
1851                    }
1852                    catch (Exception e) {
1853                            _log.error(e, e);
1854    
1855                            throw new RemoteException(e.getMessage());
1856                    }
1857            }
1858    
1859            public static void getSubfolderIds(long repositoryId, Long[] folderIds,
1860                    long folderId) throws RemoteException {
1861                    try {
1862                            DLAppServiceUtil.getSubfolderIds(repositoryId,
1863                                    ListUtil.toList(folderIds), folderId);
1864                    }
1865                    catch (Exception e) {
1866                            _log.error(e, e);
1867    
1868                            throw new RemoteException(e.getMessage());
1869                    }
1870            }
1871    
1872            /**
1873            * Returns all the descendant folders of the folder with the primary key.
1874            *
1875            * @param repositoryId the primary key of the repository
1876            * @param folderId the primary key of the folder
1877            * @return the descendant folders of the folder with the primary key
1878            * @throws PortalException if the repository or parent folder could not be
1879            found
1880            * @throws SystemException if a system exception occurred
1881            */
1882            public static java.lang.Long[] getSubfolderIds(long repositoryId,
1883                    long folderId) throws RemoteException {
1884                    try {
1885                            java.util.List<java.lang.Long> returnValue = DLAppServiceUtil.getSubfolderIds(repositoryId,
1886                                            folderId);
1887    
1888                            return returnValue.toArray(new java.lang.Long[returnValue.size()]);
1889                    }
1890                    catch (Exception e) {
1891                            _log.error(e, e);
1892    
1893                            throw new RemoteException(e.getMessage());
1894                    }
1895            }
1896    
1897            /**
1898            * Returns descendant folders of the folder with the primary key, optionally
1899            * limiting to one level deep.
1900            *
1901            * @param repositoryId the primary key of the repository
1902            * @param folderId the primary key of the folder
1903            * @param recurse whether to recurse through each subfolder
1904            * @return the descendant folders of the folder with the primary key
1905            * @throws PortalException if the repository or parent folder could not be
1906            found
1907            * @throws SystemException if a system exception occurred
1908            */
1909            public static java.lang.Long[] getSubfolderIds(long repositoryId,
1910                    long folderId, boolean recurse) throws RemoteException {
1911                    try {
1912                            java.util.List<java.lang.Long> returnValue = DLAppServiceUtil.getSubfolderIds(repositoryId,
1913                                            folderId, recurse);
1914    
1915                            return returnValue.toArray(new java.lang.Long[returnValue.size()]);
1916                    }
1917                    catch (Exception e) {
1918                            _log.error(e, e);
1919    
1920                            throw new RemoteException(e.getMessage());
1921                    }
1922            }
1923    
1924            /**
1925            * Returns all the temporary file entry names.
1926            *
1927            * @param groupId the primary key of the group
1928            * @param folderId the primary key of the folder where the file entry will
1929            eventually reside
1930            * @param tempFolderName the temporary folder's name
1931            * @return the temporary file entry names
1932            * @throws PortalException if the folder was invalid
1933            * @throws SystemException if a system exception occurred
1934            * @see #addTempFileEntry(long, long, String, String, File, String)
1935            * @see com.liferay.portal.kernel.util.TempFileUtil
1936            */
1937            public static java.lang.String[] getTempFileEntryNames(long groupId,
1938                    long folderId, java.lang.String tempFolderName)
1939                    throws RemoteException {
1940                    try {
1941                            java.lang.String[] returnValue = DLAppServiceUtil.getTempFileEntryNames(groupId,
1942                                            folderId, tempFolderName);
1943    
1944                            return returnValue;
1945                    }
1946                    catch (Exception e) {
1947                            _log.error(e, e);
1948    
1949                            throw new RemoteException(e.getMessage());
1950                    }
1951            }
1952    
1953            /**
1954            * Moves the file entry to the new folder.
1955            *
1956            * @param fileEntryId the primary key of the file entry
1957            * @param newFolderId the primary key of the new folder
1958            * @param serviceContext the service context to be applied
1959            * @return the file entry
1960            * @throws PortalException if the file entry or the new folder could not be
1961            found
1962            * @throws SystemException if a system exception occurred
1963            */
1964            public static com.liferay.portal.kernel.repository.model.FileEntrySoap moveFileEntry(
1965                    long fileEntryId, long newFolderId,
1966                    com.liferay.portal.service.ServiceContext serviceContext)
1967                    throws RemoteException {
1968                    try {
1969                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.moveFileEntry(fileEntryId,
1970                                            newFolderId, serviceContext);
1971    
1972                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
1973                    }
1974                    catch (Exception e) {
1975                            _log.error(e, e);
1976    
1977                            throw new RemoteException(e.getMessage());
1978                    }
1979            }
1980    
1981            /**
1982            * Moves the file entry from a trashed folder to the new folder.
1983            *
1984            * @param fileEntryId the primary key of the file entry
1985            * @param newFolderId the primary key of the new folder
1986            * @param serviceContext the service context to be applied
1987            * @return the file entry
1988            * @throws PortalException if the file entry or the new folder could not be
1989            found
1990            * @throws SystemException if a system exception occurred
1991            */
1992            public static com.liferay.portal.kernel.repository.model.FileEntrySoap moveFileEntryFromTrash(
1993                    long fileEntryId, long newFolderId,
1994                    com.liferay.portal.service.ServiceContext serviceContext)
1995                    throws RemoteException {
1996                    try {
1997                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.moveFileEntryFromTrash(fileEntryId,
1998                                            newFolderId, serviceContext);
1999    
2000                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
2001                    }
2002                    catch (Exception e) {
2003                            _log.error(e, e);
2004    
2005                            throw new RemoteException(e.getMessage());
2006                    }
2007            }
2008    
2009            /**
2010            * Moves the file entry with the primary key to the trash portlet.
2011            *
2012            * @param fileEntryId the primary key of the file entry
2013            * @return the file entry
2014            * @throws PortalException if the file entry could not be found
2015            * @throws SystemException if a system exception occurred
2016            */
2017            public static com.liferay.portal.kernel.repository.model.FileEntrySoap moveFileEntryToTrash(
2018                    long fileEntryId) throws RemoteException {
2019                    try {
2020                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.moveFileEntryToTrash(fileEntryId);
2021    
2022                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
2023                    }
2024                    catch (Exception e) {
2025                            _log.error(e, e);
2026    
2027                            throw new RemoteException(e.getMessage());
2028                    }
2029            }
2030    
2031            /**
2032            * Moves the file shortcut from a trashed folder to the new folder.
2033            *
2034            * @param fileShortcutId the primary key of the file shortcut
2035            * @param newFolderId the primary key of the new folder
2036            * @param serviceContext the service context to be applied
2037            * @return the file shortcut
2038            * @throws PortalException if the file entry or the new folder could not be
2039            found
2040            * @throws SystemException if a system exception occurred
2041            */
2042            public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap moveFileShortcutFromTrash(
2043                    long fileShortcutId, long newFolderId,
2044                    com.liferay.portal.service.ServiceContext serviceContext)
2045                    throws RemoteException {
2046                    try {
2047                            com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue =
2048                                    DLAppServiceUtil.moveFileShortcutFromTrash(fileShortcutId,
2049                                            newFolderId, serviceContext);
2050    
2051                            return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue);
2052                    }
2053                    catch (Exception e) {
2054                            _log.error(e, e);
2055    
2056                            throw new RemoteException(e.getMessage());
2057                    }
2058            }
2059    
2060            /**
2061            * Moves the file shortcut with the primary key to the trash portlet.
2062            *
2063            * @param fileShortcutId the primary key of the file shortcut
2064            * @return the file shortcut
2065            * @throws PortalException if the file shortcut could not be found
2066            * @throws SystemException if a system exception occurred
2067            */
2068            public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap moveFileShortcutToTrash(
2069                    long fileShortcutId) throws RemoteException {
2070                    try {
2071                            com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue =
2072                                    DLAppServiceUtil.moveFileShortcutToTrash(fileShortcutId);
2073    
2074                            return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue);
2075                    }
2076                    catch (Exception e) {
2077                            _log.error(e, e);
2078    
2079                            throw new RemoteException(e.getMessage());
2080                    }
2081            }
2082    
2083            /**
2084            * Moves the folder to the new parent folder with the primary key.
2085            *
2086            * @param folderId the primary key of the folder
2087            * @param parentFolderId the primary key of the new parent folder
2088            * @param serviceContext the service context to be applied
2089            * @return the file entry
2090            * @throws PortalException if the folder could not be found
2091            * @throws SystemException if a system exception occurred
2092            */
2093            public static com.liferay.portal.kernel.repository.model.FolderSoap moveFolder(
2094                    long folderId, long parentFolderId,
2095                    com.liferay.portal.service.ServiceContext serviceContext)
2096                    throws RemoteException {
2097                    try {
2098                            com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.moveFolder(folderId,
2099                                            parentFolderId, serviceContext);
2100    
2101                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue);
2102                    }
2103                    catch (Exception e) {
2104                            _log.error(e, e);
2105    
2106                            throw new RemoteException(e.getMessage());
2107                    }
2108            }
2109    
2110            /**
2111            * Moves the folder with the primary key from the trash portlet to the new
2112            * parent folder with the primary key.
2113            *
2114            * @param folderId the primary key of the folder
2115            * @param parentFolderId the primary key of the new parent folder
2116            * @param serviceContext the service context to be applied
2117            * @return the file entry
2118            * @throws PortalException if the folder could not be found
2119            * @throws SystemException if a system exception occurred
2120            */
2121            public static com.liferay.portal.kernel.repository.model.FolderSoap moveFolderFromTrash(
2122                    long folderId, long parentFolderId,
2123                    com.liferay.portal.service.ServiceContext serviceContext)
2124                    throws RemoteException {
2125                    try {
2126                            com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.moveFolderFromTrash(folderId,
2127                                            parentFolderId, serviceContext);
2128    
2129                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue);
2130                    }
2131                    catch (Exception e) {
2132                            _log.error(e, e);
2133    
2134                            throw new RemoteException(e.getMessage());
2135                    }
2136            }
2137    
2138            /**
2139            * Moves the folder with the primary key to the trash portlet.
2140            *
2141            * @param folderId the primary key of the folder
2142            * @return the file entry
2143            * @throws PortalException if the folder could not be found
2144            * @throws SystemException if a system exception occurred
2145            */
2146            public static com.liferay.portal.kernel.repository.model.FolderSoap moveFolderToTrash(
2147                    long folderId) throws RemoteException {
2148                    try {
2149                            com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.moveFolderToTrash(folderId);
2150    
2151                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue);
2152                    }
2153                    catch (Exception e) {
2154                            _log.error(e, e);
2155    
2156                            throw new RemoteException(e.getMessage());
2157                    }
2158            }
2159    
2160            /**
2161            * Restores the file entry with the primary key from the trash portlet.
2162            *
2163            * @param fileEntryId the primary key of the file entry
2164            * @throws PortalException if the file entry could not be found
2165            * @throws SystemException if a system exception occurred
2166            */
2167            public static void restoreFileEntryFromTrash(long fileEntryId)
2168                    throws RemoteException {
2169                    try {
2170                            DLAppServiceUtil.restoreFileEntryFromTrash(fileEntryId);
2171                    }
2172                    catch (Exception e) {
2173                            _log.error(e, e);
2174    
2175                            throw new RemoteException(e.getMessage());
2176                    }
2177            }
2178    
2179            /**
2180            * Restores the file shortcut with the primary key from the trash portlet.
2181            *
2182            * @param fileShortcutId the primary key of the file shortcut
2183            * @throws PortalException if the file shortcut could not be found
2184            * @throws SystemException if a system exception occurred
2185            */
2186            public static void restoreFileShortcutFromTrash(long fileShortcutId)
2187                    throws RemoteException {
2188                    try {
2189                            DLAppServiceUtil.restoreFileShortcutFromTrash(fileShortcutId);
2190                    }
2191                    catch (Exception e) {
2192                            _log.error(e, e);
2193    
2194                            throw new RemoteException(e.getMessage());
2195                    }
2196            }
2197    
2198            /**
2199            * Restores the folder with the primary key from the trash portlet.
2200            *
2201            * @param folderId the primary key of the folder
2202            * @throws PortalException if the folder could not be found
2203            * @throws SystemException if a system exception occurred
2204            */
2205            public static void restoreFolderFromTrash(long folderId)
2206                    throws RemoteException {
2207                    try {
2208                            DLAppServiceUtil.restoreFolderFromTrash(folderId);
2209                    }
2210                    catch (Exception e) {
2211                            _log.error(e, e);
2212    
2213                            throw new RemoteException(e.getMessage());
2214                    }
2215            }
2216    
2217            /**
2218            * Reverts the file entry to a previous version. A new version will be
2219            * created based on the previous version and metadata.
2220            *
2221            * @param fileEntryId the primary key of the file entry
2222            * @param version the version to revert back to
2223            * @param serviceContext the service context to be applied
2224            * @throws PortalException if the file entry or version could not be found
2225            * @throws SystemException if a system exception occurred
2226            */
2227            public static void revertFileEntry(long fileEntryId,
2228                    java.lang.String version,
2229                    com.liferay.portal.service.ServiceContext serviceContext)
2230                    throws RemoteException {
2231                    try {
2232                            DLAppServiceUtil.revertFileEntry(fileEntryId, version,
2233                                    serviceContext);
2234                    }
2235                    catch (Exception e) {
2236                            _log.error(e, e);
2237    
2238                            throw new RemoteException(e.getMessage());
2239                    }
2240            }
2241    
2242            /**
2243            * Subscribe the user to changes in documents of the file entry type. This
2244            * method is only supported by the Liferay repository.
2245            *
2246            * @param groupId the primary key of the file entry type's group
2247            * @param fileEntryTypeId the primary key of the file entry type
2248            * @throws PortalException if the user or group could not be found, or if
2249            subscribing was not permissible
2250            * @throws SystemException if a system exception occurred
2251            */
2252            public static void subscribeFileEntryType(long groupId, long fileEntryTypeId)
2253                    throws RemoteException {
2254                    try {
2255                            DLAppServiceUtil.subscribeFileEntryType(groupId, fileEntryTypeId);
2256                    }
2257                    catch (Exception e) {
2258                            _log.error(e, e);
2259    
2260                            throw new RemoteException(e.getMessage());
2261                    }
2262            }
2263    
2264            /**
2265            * Subscribe the user to document changes in the folder. This method is only
2266            * supported by the Liferay repository.
2267            *
2268            * @param groupId the primary key of the folder's group
2269            * @param folderId the primary key of the folder
2270            * @throws PortalException if the user or group could not be found, or if
2271            subscribing was not permissible
2272            * @throws SystemException if a system exception occurred
2273            */
2274            public static void subscribeFolder(long groupId, long folderId)
2275                    throws RemoteException {
2276                    try {
2277                            DLAppServiceUtil.subscribeFolder(groupId, folderId);
2278                    }
2279                    catch (Exception e) {
2280                            _log.error(e, e);
2281    
2282                            throw new RemoteException(e.getMessage());
2283                    }
2284            }
2285    
2286            /**
2287            * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
2288            boolean, String, ServiceContext)}.
2289            */
2290            public static void unlockFileEntry(long fileEntryId)
2291                    throws RemoteException {
2292                    try {
2293                            DLAppServiceUtil.unlockFileEntry(fileEntryId);
2294                    }
2295                    catch (Exception e) {
2296                            _log.error(e, e);
2297    
2298                            throw new RemoteException(e.getMessage());
2299                    }
2300            }
2301    
2302            /**
2303            * @deprecated As of 6.2.0, replaced by {@link #checkInFileEntry(long,
2304            String)}.
2305            */
2306            public static void unlockFileEntry(long fileEntryId,
2307                    java.lang.String lockUuid) throws RemoteException {
2308                    try {
2309                            DLAppServiceUtil.unlockFileEntry(fileEntryId, lockUuid);
2310                    }
2311                    catch (Exception e) {
2312                            _log.error(e, e);
2313    
2314                            throw new RemoteException(e.getMessage());
2315                    }
2316            }
2317    
2318            /**
2319            * Unlocks the folder. This method is primarily used by WebDAV.
2320            *
2321            * @param repositoryId the primary key of the repository
2322            * @param folderId the primary key of the folder
2323            * @param lockUuid the lock's UUID
2324            * @throws PortalException if the repository or folder could not be found
2325            * @throws SystemException if a system exception occurred
2326            */
2327            public static void unlockFolder(long repositoryId, long folderId,
2328                    java.lang.String lockUuid) throws RemoteException {
2329                    try {
2330                            DLAppServiceUtil.unlockFolder(repositoryId, folderId, lockUuid);
2331                    }
2332                    catch (Exception e) {
2333                            _log.error(e, e);
2334    
2335                            throw new RemoteException(e.getMessage());
2336                    }
2337            }
2338    
2339            /**
2340            * Unlocks the folder. This method is primarily used by WebDAV.
2341            *
2342            * @param repositoryId the primary key of the repository
2343            * @param parentFolderId the primary key of the parent folder
2344            * @param name the folder's name
2345            * @param lockUuid the lock's UUID
2346            * @throws PortalException if the repository or folder could not be found
2347            * @throws SystemException if a system exception occurred
2348            */
2349            public static void unlockFolder(long repositoryId, long parentFolderId,
2350                    java.lang.String name, java.lang.String lockUuid)
2351                    throws RemoteException {
2352                    try {
2353                            DLAppServiceUtil.unlockFolder(repositoryId, parentFolderId, name,
2354                                    lockUuid);
2355                    }
2356                    catch (Exception e) {
2357                            _log.error(e, e);
2358    
2359                            throw new RemoteException(e.getMessage());
2360                    }
2361            }
2362    
2363            /**
2364            * Unsubscribe the user from changes in documents of the file entry type.
2365            * This method is only supported by the Liferay repository.
2366            *
2367            * @param groupId the primary key of the file entry type's group
2368            * @param fileEntryTypeId the primary key of the file entry type
2369            * @throws PortalException if the user or group could not be found, or if
2370            unsubscribing was not permissible
2371            * @throws SystemException if a system exception occurred
2372            */
2373            public static void unsubscribeFileEntryType(long groupId,
2374                    long fileEntryTypeId) throws RemoteException {
2375                    try {
2376                            DLAppServiceUtil.unsubscribeFileEntryType(groupId, fileEntryTypeId);
2377                    }
2378                    catch (Exception e) {
2379                            _log.error(e, e);
2380    
2381                            throw new RemoteException(e.getMessage());
2382                    }
2383            }
2384    
2385            /**
2386            * Unsubscribe the user from document changes in the folder. This method is
2387            * only supported by the Liferay repository.
2388            *
2389            * @param groupId the primary key of the folder's group
2390            * @param folderId the primary key of the folder
2391            * @throws PortalException if the user or group could not be found, or if
2392            unsubscribing was not permissible
2393            * @throws SystemException if a system exception occurred
2394            */
2395            public static void unsubscribeFolder(long groupId, long folderId)
2396                    throws RemoteException {
2397                    try {
2398                            DLAppServiceUtil.unsubscribeFolder(groupId, folderId);
2399                    }
2400                    catch (Exception e) {
2401                            _log.error(e, e);
2402    
2403                            throw new RemoteException(e.getMessage());
2404                    }
2405            }
2406    
2407            /**
2408            * Updates a file entry and associated metadata based on a byte array
2409            * object. If the file data is <code>null</code>, then only the associated
2410            * metadata (i.e., <code>title</code>, <code>description</code>, and
2411            * parameters in the <code>serviceContext</code>) will be updated.
2412            *
2413            * <p>
2414            * This method takes two file names, the <code>sourceFileName</code> and the
2415            * <code>title</code>. The <code>sourceFileName</code> corresponds to the
2416            * name of the actual file being uploaded. The <code>title</code>
2417            * corresponds to a name the client wishes to assign this file after it has
2418            * been uploaded to the portal.
2419            * </p>
2420            *
2421            * @param fileEntryId the primary key of the file entry
2422            * @param sourceFileName the original file's name (optionally
2423            <code>null</code>)
2424            * @param mimeType the file's MIME type (optionally <code>null</code>)
2425            * @param title the new name to be assigned to the file (optionally <code>
2426            <code>null</code></code>)
2427            * @param description the file's new description
2428            * @param changeLog the file's version change log (optionally
2429            <code>null</code>)
2430            * @param majorVersion whether the new file version is a major version
2431            * @param bytes the file's data (optionally <code>null</code>)
2432            * @param serviceContext the service context to be applied. Can set the
2433            asset category IDs, asset tag names, and expando bridge
2434            attributes for the file entry. In a Liferay repository, it may
2435            include:  <ul> <li> fileEntryTypeId - ID for a custom file entry
2436            type </li> <li> fieldsMap - mapping for fields associated with a
2437            custom file entry type </li> </ul>
2438            * @return the file entry
2439            * @throws PortalException if the file entry could not be found
2440            * @throws SystemException if a system exception occurred
2441            */
2442            public static com.liferay.portal.kernel.repository.model.FileEntrySoap updateFileEntry(
2443                    long fileEntryId, java.lang.String sourceFileName,
2444                    java.lang.String mimeType, java.lang.String title,
2445                    java.lang.String description, java.lang.String changeLog,
2446                    boolean majorVersion, byte[] bytes,
2447                    com.liferay.portal.service.ServiceContext serviceContext)
2448                    throws RemoteException {
2449                    try {
2450                            com.liferay.portal.kernel.repository.model.FileEntry returnValue = DLAppServiceUtil.updateFileEntry(fileEntryId,
2451                                            sourceFileName, mimeType, title, description, changeLog,
2452                                            majorVersion, bytes, serviceContext);
2453    
2454                            return com.liferay.portal.kernel.repository.model.FileEntrySoap.toSoapModel(returnValue);
2455                    }
2456                    catch (Exception e) {
2457                            _log.error(e, e);
2458    
2459                            throw new RemoteException(e.getMessage());
2460                    }
2461            }
2462    
2463            /**
2464            * Updates a file shortcut to the existing file entry. This method is only
2465            * supported by the Liferay repository.
2466            *
2467            * @param fileShortcutId the primary key of the file shortcut
2468            * @param folderId the primary key of the file shortcut's parent folder
2469            * @param toFileEntryId the primary key of the file shortcut's file entry
2470            * @param serviceContext the service context to be applied. Can set the
2471            asset category IDs, asset tag names, and expando bridge
2472            attributes for the file entry.
2473            * @return the file shortcut
2474            * @throws PortalException if the file shortcut, folder, or file entry could
2475            not be found
2476            * @throws SystemException if a system exception occurred
2477            */
2478            public static com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap updateFileShortcut(
2479                    long fileShortcutId, long folderId, long toFileEntryId,
2480                    com.liferay.portal.service.ServiceContext serviceContext)
2481                    throws RemoteException {
2482                    try {
2483                            com.liferay.portlet.documentlibrary.model.DLFileShortcut returnValue =
2484                                    DLAppServiceUtil.updateFileShortcut(fileShortcutId, folderId,
2485                                            toFileEntryId, serviceContext);
2486    
2487                            return com.liferay.portlet.documentlibrary.model.DLFileShortcutSoap.toSoapModel(returnValue);
2488                    }
2489                    catch (Exception e) {
2490                            _log.error(e, e);
2491    
2492                            throw new RemoteException(e.getMessage());
2493                    }
2494            }
2495    
2496            /**
2497            * Updates the folder.
2498            *
2499            * @param folderId the primary key of the folder
2500            * @param name the folder's new name
2501            * @param description the folder's new description
2502            * @param serviceContext the service context to be applied. In a Liferay
2503            repository, it may include:  <ul> <li> defaultFileEntryTypeId -
2504            the file entry type to default all Liferay file entries to </li>
2505            <li> dlFileEntryTypesSearchContainerPrimaryKeys - a
2506            comma-delimited list of file entry type primary keys allowed in
2507            the given folder and all descendants </li> <li>
2508            overrideFileEntryTypes - boolean specifying whether to override
2509            ancestral folder's restriction of file entry types allowed </li>
2510            <li> workflowDefinitionXYZ - the workflow definition name
2511            specified per file entry type. The parameter name must be the
2512            string <code>workflowDefinition</code> appended by the <code>
2513            fileEntryTypeId</code> (optionally <code>0</code>). </li> </ul>
2514            * @return the folder
2515            * @throws PortalException if the current or new parent folder could not be
2516            found or if the new parent folder's information was invalid
2517            * @throws SystemException if a system exception occurred
2518            */
2519            public static com.liferay.portal.kernel.repository.model.FolderSoap updateFolder(
2520                    long folderId, java.lang.String name, java.lang.String description,
2521                    com.liferay.portal.service.ServiceContext serviceContext)
2522                    throws RemoteException {
2523                    try {
2524                            com.liferay.portal.kernel.repository.model.Folder returnValue = DLAppServiceUtil.updateFolder(folderId,
2525                                            name, description, serviceContext);
2526    
2527                            return com.liferay.portal.kernel.repository.model.FolderSoap.toSoapModel(returnValue);
2528                    }
2529                    catch (Exception e) {
2530                            _log.error(e, e);
2531    
2532                            throw new RemoteException(e.getMessage());
2533                    }
2534            }
2535    
2536            /**
2537            * Returns <code>true</code> if the file entry is checked out. This method
2538            * is primarily used by WebDAV.
2539            *
2540            * @param repositoryId the primary key for the repository
2541            * @param fileEntryId the primary key for the file entry
2542            * @param lockUuid the lock's UUID
2543            * @return <code>true</code> if the file entry is checked out;
2544            <code>false</code> otherwise
2545            * @throws PortalException if the file entry could not be found
2546            * @throws SystemException if a system exception occurred
2547            */
2548            public static boolean verifyFileEntryCheckOut(long repositoryId,
2549                    long fileEntryId, java.lang.String lockUuid) throws RemoteException {
2550                    try {
2551                            boolean returnValue = DLAppServiceUtil.verifyFileEntryCheckOut(repositoryId,
2552                                            fileEntryId, lockUuid);
2553    
2554                            return returnValue;
2555                    }
2556                    catch (Exception e) {
2557                            _log.error(e, e);
2558    
2559                            throw new RemoteException(e.getMessage());
2560                    }
2561            }
2562    
2563            public static boolean verifyFileEntryLock(long repositoryId,
2564                    long fileEntryId, java.lang.String lockUuid) throws RemoteException {
2565                    try {
2566                            boolean returnValue = DLAppServiceUtil.verifyFileEntryLock(repositoryId,
2567                                            fileEntryId, lockUuid);
2568    
2569                            return returnValue;
2570                    }
2571                    catch (Exception e) {
2572                            _log.error(e, e);
2573    
2574                            throw new RemoteException(e.getMessage());
2575                    }
2576            }
2577    
2578            /**
2579            * Returns <code>true</code> if the inheritable lock exists. This method is
2580            * primarily used by WebDAV.
2581            *
2582            * @param repositoryId the primary key for the repository
2583            * @param folderId the primary key for the folder
2584            * @param lockUuid the lock's UUID
2585            * @return <code>true</code> if the inheritable lock exists;
2586            <code>false</code> otherwise
2587            * @throws PortalException if the folder could not be found
2588            * @throws SystemException if a system exception occurred
2589            */
2590            public static boolean verifyInheritableLock(long repositoryId,
2591                    long folderId, java.lang.String lockUuid) throws RemoteException {
2592                    try {
2593                            boolean returnValue = DLAppServiceUtil.verifyInheritableLock(repositoryId,
2594                                            folderId, lockUuid);
2595    
2596                            return returnValue;
2597                    }
2598                    catch (Exception e) {
2599                            _log.error(e, e);
2600    
2601                            throw new RemoteException(e.getMessage());
2602                    }
2603            }
2604    
2605            private static Log _log = LogFactoryUtil.getLog(DLAppServiceSoap.class);
2606    }