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