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