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