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