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.security.auth.HttpPrincipal;
022    import com.liferay.portal.kernel.util.MethodHandler;
023    import com.liferay.portal.kernel.util.MethodKey;
024    import com.liferay.portal.service.http.TunnelUtil;
025    
026    import com.liferay.portlet.documentlibrary.service.DLAppServiceUtil;
027    
028    /**
029     * Provides the HTTP utility for the
030     * {@link DLAppServiceUtil} service utility. The
031     * static methods of this class calls the same methods of the service utility.
032     * However, the signatures are different because it requires an additional
033     * {@link HttpPrincipal} parameter.
034     *
035     * <p>
036     * The benefits of using the HTTP utility is that it is fast and allows for
037     * tunneling without the cost of serializing to text. The drawback is that it
038     * only works with Java.
039     * </p>
040     *
041     * <p>
042     * Set the property <b>tunnel.servlet.hosts.allowed</b> in portal.properties to
043     * configure security.
044     * </p>
045     *
046     * <p>
047     * The HTTP utility is only generated for remote services.
048     * </p>
049     *
050     * @author Brian Wing Shun Chan
051     * @see DLAppServiceSoap
052     * @see HttpPrincipal
053     * @see DLAppServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class DLAppServiceHttp {
058            public static com.liferay.portal.kernel.repository.model.FileEntry addFileEntry(
059                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
060                    java.lang.String sourceFileName, java.lang.String mimeType,
061                    java.lang.String title, java.lang.String description,
062                    java.lang.String changeLog, byte[] bytes,
063                    com.liferay.portal.service.ServiceContext serviceContext)
064                    throws com.liferay.portal.kernel.exception.PortalException {
065                    try {
066                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
067                                            "addFileEntry", _addFileEntryParameterTypes0);
068    
069                            MethodHandler methodHandler = new MethodHandler(methodKey,
070                                            repositoryId, folderId, sourceFileName, mimeType, title,
071                                            description, changeLog, bytes, serviceContext);
072    
073                            Object returnObj = null;
074    
075                            try {
076                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
077                            }
078                            catch (Exception e) {
079                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
080                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
081                                    }
082    
083                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
084                            }
085    
086                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
087                    }
088                    catch (com.liferay.portal.kernel.exception.SystemException se) {
089                            _log.error(se, se);
090    
091                            throw se;
092                    }
093            }
094    
095            public static com.liferay.portal.kernel.repository.model.FileEntry addFileEntry(
096                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
097                    java.lang.String sourceFileName, java.lang.String mimeType,
098                    java.lang.String title, java.lang.String description,
099                    java.lang.String changeLog, java.io.File file,
100                    com.liferay.portal.service.ServiceContext serviceContext)
101                    throws com.liferay.portal.kernel.exception.PortalException {
102                    try {
103                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
104                                            "addFileEntry", _addFileEntryParameterTypes1);
105    
106                            MethodHandler methodHandler = new MethodHandler(methodKey,
107                                            repositoryId, folderId, sourceFileName, mimeType, title,
108                                            description, changeLog, file, serviceContext);
109    
110                            Object returnObj = null;
111    
112                            try {
113                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
114                            }
115                            catch (Exception e) {
116                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
117                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
118                                    }
119    
120                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
121                            }
122    
123                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
124                    }
125                    catch (com.liferay.portal.kernel.exception.SystemException se) {
126                            _log.error(se, se);
127    
128                            throw se;
129                    }
130            }
131    
132            public static com.liferay.portal.kernel.repository.model.FileEntry addFileEntry(
133                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
134                    java.lang.String sourceFileName, java.lang.String mimeType,
135                    java.lang.String title, java.lang.String description,
136                    java.lang.String changeLog, java.io.InputStream is, long size,
137                    com.liferay.portal.service.ServiceContext serviceContext)
138                    throws com.liferay.portal.kernel.exception.PortalException {
139                    try {
140                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
141                                            "addFileEntry", _addFileEntryParameterTypes2);
142    
143                            MethodHandler methodHandler = new MethodHandler(methodKey,
144                                            repositoryId, folderId, sourceFileName, mimeType, title,
145                                            description, changeLog, is, size, serviceContext);
146    
147                            Object returnObj = null;
148    
149                            try {
150                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
151                            }
152                            catch (Exception e) {
153                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
154                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
155                                    }
156    
157                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
158                            }
159    
160                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
161                    }
162                    catch (com.liferay.portal.kernel.exception.SystemException se) {
163                            _log.error(se, se);
164    
165                            throw se;
166                    }
167            }
168    
169            public static com.liferay.portal.kernel.repository.model.FileShortcut addFileShortcut(
170                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
171                    long toFileEntryId,
172                    com.liferay.portal.service.ServiceContext serviceContext)
173                    throws com.liferay.portal.kernel.exception.PortalException {
174                    try {
175                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
176                                            "addFileShortcut", _addFileShortcutParameterTypes3);
177    
178                            MethodHandler methodHandler = new MethodHandler(methodKey,
179                                            repositoryId, folderId, toFileEntryId, serviceContext);
180    
181                            Object returnObj = null;
182    
183                            try {
184                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
185                            }
186                            catch (Exception e) {
187                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
188                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
189                                    }
190    
191                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
192                            }
193    
194                            return (com.liferay.portal.kernel.repository.model.FileShortcut)returnObj;
195                    }
196                    catch (com.liferay.portal.kernel.exception.SystemException se) {
197                            _log.error(se, se);
198    
199                            throw se;
200                    }
201            }
202    
203            public static com.liferay.portal.kernel.repository.model.Folder addFolder(
204                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
205                    java.lang.String name, java.lang.String description,
206                    com.liferay.portal.service.ServiceContext serviceContext)
207                    throws com.liferay.portal.kernel.exception.PortalException {
208                    try {
209                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
210                                            "addFolder", _addFolderParameterTypes4);
211    
212                            MethodHandler methodHandler = new MethodHandler(methodKey,
213                                            repositoryId, parentFolderId, name, description,
214                                            serviceContext);
215    
216                            Object returnObj = null;
217    
218                            try {
219                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
220                            }
221                            catch (Exception e) {
222                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
223                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
224                                    }
225    
226                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
227                            }
228    
229                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
230                    }
231                    catch (com.liferay.portal.kernel.exception.SystemException se) {
232                            _log.error(se, se);
233    
234                            throw se;
235                    }
236            }
237    
238            public static com.liferay.portal.kernel.repository.model.FileEntry addTempFileEntry(
239                    HttpPrincipal httpPrincipal, long groupId, long folderId,
240                    java.lang.String folderName, java.lang.String fileName,
241                    java.io.File file, java.lang.String mimeType)
242                    throws com.liferay.portal.kernel.exception.PortalException {
243                    try {
244                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
245                                            "addTempFileEntry", _addTempFileEntryParameterTypes5);
246    
247                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
248                                            folderId, folderName, fileName, file, mimeType);
249    
250                            Object returnObj = null;
251    
252                            try {
253                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
254                            }
255                            catch (Exception e) {
256                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
257                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
258                                    }
259    
260                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
261                            }
262    
263                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
264                    }
265                    catch (com.liferay.portal.kernel.exception.SystemException se) {
266                            _log.error(se, se);
267    
268                            throw se;
269                    }
270            }
271    
272            public static com.liferay.portal.kernel.repository.model.FileEntry addTempFileEntry(
273                    HttpPrincipal httpPrincipal, long groupId, long folderId,
274                    java.lang.String folderName, java.lang.String fileName,
275                    java.io.InputStream inputStream, java.lang.String mimeType)
276                    throws com.liferay.portal.kernel.exception.PortalException {
277                    try {
278                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
279                                            "addTempFileEntry", _addTempFileEntryParameterTypes6);
280    
281                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
282                                            folderId, folderName, fileName, inputStream, mimeType);
283    
284                            Object returnObj = null;
285    
286                            try {
287                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
288                            }
289                            catch (Exception e) {
290                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
291                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
292                                    }
293    
294                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
295                            }
296    
297                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
298                    }
299                    catch (com.liferay.portal.kernel.exception.SystemException se) {
300                            _log.error(se, se);
301    
302                            throw se;
303                    }
304            }
305    
306            public static void cancelCheckOut(HttpPrincipal httpPrincipal,
307                    long fileEntryId)
308                    throws com.liferay.portal.kernel.exception.PortalException {
309                    try {
310                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
311                                            "cancelCheckOut", _cancelCheckOutParameterTypes7);
312    
313                            MethodHandler methodHandler = new MethodHandler(methodKey,
314                                            fileEntryId);
315    
316                            try {
317                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
318                            }
319                            catch (Exception e) {
320                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
321                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
322                                    }
323    
324                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
325                            }
326                    }
327                    catch (com.liferay.portal.kernel.exception.SystemException se) {
328                            _log.error(se, se);
329    
330                            throw se;
331                    }
332            }
333    
334            public static void checkInFileEntry(HttpPrincipal httpPrincipal,
335                    long fileEntryId, boolean majorVersion, java.lang.String changeLog,
336                    com.liferay.portal.service.ServiceContext serviceContext)
337                    throws com.liferay.portal.kernel.exception.PortalException {
338                    try {
339                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
340                                            "checkInFileEntry", _checkInFileEntryParameterTypes8);
341    
342                            MethodHandler methodHandler = new MethodHandler(methodKey,
343                                            fileEntryId, majorVersion, changeLog, serviceContext);
344    
345                            try {
346                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
347                            }
348                            catch (Exception e) {
349                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
350                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
351                                    }
352    
353                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
354                            }
355                    }
356                    catch (com.liferay.portal.kernel.exception.SystemException se) {
357                            _log.error(se, se);
358    
359                            throw se;
360                    }
361            }
362    
363            public static void checkInFileEntry(HttpPrincipal httpPrincipal,
364                    long fileEntryId, java.lang.String lockUuid,
365                    com.liferay.portal.service.ServiceContext serviceContext)
366                    throws com.liferay.portal.kernel.exception.PortalException {
367                    try {
368                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
369                                            "checkInFileEntry", _checkInFileEntryParameterTypes9);
370    
371                            MethodHandler methodHandler = new MethodHandler(methodKey,
372                                            fileEntryId, lockUuid, serviceContext);
373    
374                            try {
375                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
376                            }
377                            catch (Exception e) {
378                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
379                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
380                                    }
381    
382                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
383                            }
384                    }
385                    catch (com.liferay.portal.kernel.exception.SystemException se) {
386                            _log.error(se, se);
387    
388                            throw se;
389                    }
390            }
391    
392            public static void checkOutFileEntry(HttpPrincipal httpPrincipal,
393                    long fileEntryId,
394                    com.liferay.portal.service.ServiceContext serviceContext)
395                    throws com.liferay.portal.kernel.exception.PortalException {
396                    try {
397                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
398                                            "checkOutFileEntry", _checkOutFileEntryParameterTypes10);
399    
400                            MethodHandler methodHandler = new MethodHandler(methodKey,
401                                            fileEntryId, serviceContext);
402    
403                            try {
404                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
405                            }
406                            catch (Exception e) {
407                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
408                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
409                                    }
410    
411                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
412                            }
413                    }
414                    catch (com.liferay.portal.kernel.exception.SystemException se) {
415                            _log.error(se, se);
416    
417                            throw se;
418                    }
419            }
420    
421            public static com.liferay.portal.kernel.repository.model.FileEntry checkOutFileEntry(
422                    HttpPrincipal httpPrincipal, long fileEntryId, java.lang.String owner,
423                    long expirationTime,
424                    com.liferay.portal.service.ServiceContext serviceContext)
425                    throws com.liferay.portal.kernel.exception.PortalException {
426                    try {
427                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
428                                            "checkOutFileEntry", _checkOutFileEntryParameterTypes11);
429    
430                            MethodHandler methodHandler = new MethodHandler(methodKey,
431                                            fileEntryId, owner, expirationTime, serviceContext);
432    
433                            Object returnObj = null;
434    
435                            try {
436                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
437                            }
438                            catch (Exception e) {
439                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
440                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
441                                    }
442    
443                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
444                            }
445    
446                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
447                    }
448                    catch (com.liferay.portal.kernel.exception.SystemException se) {
449                            _log.error(se, se);
450    
451                            throw se;
452                    }
453            }
454    
455            public static com.liferay.portal.kernel.repository.model.Folder copyFolder(
456                    HttpPrincipal httpPrincipal, long repositoryId, long sourceFolderId,
457                    long parentFolderId, java.lang.String name,
458                    java.lang.String description,
459                    com.liferay.portal.service.ServiceContext serviceContext)
460                    throws com.liferay.portal.kernel.exception.PortalException {
461                    try {
462                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
463                                            "copyFolder", _copyFolderParameterTypes12);
464    
465                            MethodHandler methodHandler = new MethodHandler(methodKey,
466                                            repositoryId, sourceFolderId, parentFolderId, name,
467                                            description, serviceContext);
468    
469                            Object returnObj = null;
470    
471                            try {
472                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
473                            }
474                            catch (Exception e) {
475                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
476                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
477                                    }
478    
479                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
480                            }
481    
482                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
483                    }
484                    catch (com.liferay.portal.kernel.exception.SystemException se) {
485                            _log.error(se, se);
486    
487                            throw se;
488                    }
489            }
490    
491            public static void deleteFileEntry(HttpPrincipal httpPrincipal,
492                    long fileEntryId)
493                    throws com.liferay.portal.kernel.exception.PortalException {
494                    try {
495                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
496                                            "deleteFileEntry", _deleteFileEntryParameterTypes13);
497    
498                            MethodHandler methodHandler = new MethodHandler(methodKey,
499                                            fileEntryId);
500    
501                            try {
502                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
503                            }
504                            catch (Exception e) {
505                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
506                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
507                                    }
508    
509                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
510                            }
511                    }
512                    catch (com.liferay.portal.kernel.exception.SystemException se) {
513                            _log.error(se, se);
514    
515                            throw se;
516                    }
517            }
518    
519            public static void deleteFileEntryByTitle(HttpPrincipal httpPrincipal,
520                    long repositoryId, long folderId, java.lang.String title)
521                    throws com.liferay.portal.kernel.exception.PortalException {
522                    try {
523                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
524                                            "deleteFileEntryByTitle",
525                                            _deleteFileEntryByTitleParameterTypes14);
526    
527                            MethodHandler methodHandler = new MethodHandler(methodKey,
528                                            repositoryId, folderId, title);
529    
530                            try {
531                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
532                            }
533                            catch (Exception e) {
534                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
535                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
536                                    }
537    
538                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
539                            }
540                    }
541                    catch (com.liferay.portal.kernel.exception.SystemException se) {
542                            _log.error(se, se);
543    
544                            throw se;
545                    }
546            }
547    
548            public static void deleteFileShortcut(HttpPrincipal httpPrincipal,
549                    long fileShortcutId)
550                    throws com.liferay.portal.kernel.exception.PortalException {
551                    try {
552                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
553                                            "deleteFileShortcut", _deleteFileShortcutParameterTypes15);
554    
555                            MethodHandler methodHandler = new MethodHandler(methodKey,
556                                            fileShortcutId);
557    
558                            try {
559                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
560                            }
561                            catch (Exception e) {
562                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
563                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
564                                    }
565    
566                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
567                            }
568                    }
569                    catch (com.liferay.portal.kernel.exception.SystemException se) {
570                            _log.error(se, se);
571    
572                            throw se;
573                    }
574            }
575    
576            public static void deleteFileVersion(HttpPrincipal httpPrincipal,
577                    long fileEntryId, java.lang.String version)
578                    throws com.liferay.portal.kernel.exception.PortalException {
579                    try {
580                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
581                                            "deleteFileVersion", _deleteFileVersionParameterTypes16);
582    
583                            MethodHandler methodHandler = new MethodHandler(methodKey,
584                                            fileEntryId, version);
585    
586                            try {
587                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
588                            }
589                            catch (Exception e) {
590                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
591                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
592                                    }
593    
594                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
595                            }
596                    }
597                    catch (com.liferay.portal.kernel.exception.SystemException se) {
598                            _log.error(se, se);
599    
600                            throw se;
601                    }
602            }
603    
604            public static void deleteFolder(HttpPrincipal httpPrincipal, long folderId)
605                    throws com.liferay.portal.kernel.exception.PortalException {
606                    try {
607                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
608                                            "deleteFolder", _deleteFolderParameterTypes17);
609    
610                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
611    
612                            try {
613                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
614                            }
615                            catch (Exception e) {
616                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
617                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
618                                    }
619    
620                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
621                            }
622                    }
623                    catch (com.liferay.portal.kernel.exception.SystemException se) {
624                            _log.error(se, se);
625    
626                            throw se;
627                    }
628            }
629    
630            public static void deleteFolder(HttpPrincipal httpPrincipal,
631                    long repositoryId, long parentFolderId, java.lang.String name)
632                    throws com.liferay.portal.kernel.exception.PortalException {
633                    try {
634                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
635                                            "deleteFolder", _deleteFolderParameterTypes18);
636    
637                            MethodHandler methodHandler = new MethodHandler(methodKey,
638                                            repositoryId, parentFolderId, name);
639    
640                            try {
641                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
642                            }
643                            catch (Exception e) {
644                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
645                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
646                                    }
647    
648                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
649                            }
650                    }
651                    catch (com.liferay.portal.kernel.exception.SystemException se) {
652                            _log.error(se, se);
653    
654                            throw se;
655                    }
656            }
657    
658            public static void deleteTempFileEntry(HttpPrincipal httpPrincipal,
659                    long groupId, long folderId, java.lang.String folderName,
660                    java.lang.String fileName)
661                    throws com.liferay.portal.kernel.exception.PortalException {
662                    try {
663                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
664                                            "deleteTempFileEntry", _deleteTempFileEntryParameterTypes19);
665    
666                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
667                                            folderId, folderName, fileName);
668    
669                            try {
670                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
671                            }
672                            catch (Exception e) {
673                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
674                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
675                                    }
676    
677                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
678                            }
679                    }
680                    catch (com.liferay.portal.kernel.exception.SystemException se) {
681                            _log.error(se, se);
682    
683                            throw se;
684                    }
685            }
686    
687            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
688                    HttpPrincipal httpPrincipal, long repositoryId, long folderId)
689                    throws com.liferay.portal.kernel.exception.PortalException {
690                    try {
691                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
692                                            "getFileEntries", _getFileEntriesParameterTypes20);
693    
694                            MethodHandler methodHandler = new MethodHandler(methodKey,
695                                            repositoryId, folderId);
696    
697                            Object returnObj = null;
698    
699                            try {
700                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
701                            }
702                            catch (Exception e) {
703                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
704                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
705                                    }
706    
707                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
708                            }
709    
710                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
711                    }
712                    catch (com.liferay.portal.kernel.exception.SystemException se) {
713                            _log.error(se, se);
714    
715                            throw se;
716                    }
717            }
718    
719            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
720                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
721                    int start, int end)
722                    throws com.liferay.portal.kernel.exception.PortalException {
723                    try {
724                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
725                                            "getFileEntries", _getFileEntriesParameterTypes21);
726    
727                            MethodHandler methodHandler = new MethodHandler(methodKey,
728                                            repositoryId, folderId, start, end);
729    
730                            Object returnObj = null;
731    
732                            try {
733                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
734                            }
735                            catch (Exception e) {
736                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
737                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
738                                    }
739    
740                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
741                            }
742    
743                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
744                    }
745                    catch (com.liferay.portal.kernel.exception.SystemException se) {
746                            _log.error(se, se);
747    
748                            throw se;
749                    }
750            }
751    
752            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
753                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
754                    int start, int end,
755                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
756                    throws com.liferay.portal.kernel.exception.PortalException {
757                    try {
758                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
759                                            "getFileEntries", _getFileEntriesParameterTypes22);
760    
761                            MethodHandler methodHandler = new MethodHandler(methodKey,
762                                            repositoryId, folderId, start, end, obc);
763    
764                            Object returnObj = null;
765    
766                            try {
767                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
768                            }
769                            catch (Exception e) {
770                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
771                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
772                                    }
773    
774                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
775                            }
776    
777                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
778                    }
779                    catch (com.liferay.portal.kernel.exception.SystemException se) {
780                            _log.error(se, se);
781    
782                            throw se;
783                    }
784            }
785    
786            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
787                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
788                    long fileEntryTypeId)
789                    throws com.liferay.portal.kernel.exception.PortalException {
790                    try {
791                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
792                                            "getFileEntries", _getFileEntriesParameterTypes23);
793    
794                            MethodHandler methodHandler = new MethodHandler(methodKey,
795                                            repositoryId, folderId, fileEntryTypeId);
796    
797                            Object returnObj = null;
798    
799                            try {
800                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
801                            }
802                            catch (Exception e) {
803                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
804                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
805                                    }
806    
807                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
808                            }
809    
810                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
811                    }
812                    catch (com.liferay.portal.kernel.exception.SystemException se) {
813                            _log.error(se, se);
814    
815                            throw se;
816                    }
817            }
818    
819            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
820                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
821                    long fileEntryTypeId, int start, int end)
822                    throws com.liferay.portal.kernel.exception.PortalException {
823                    try {
824                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
825                                            "getFileEntries", _getFileEntriesParameterTypes24);
826    
827                            MethodHandler methodHandler = new MethodHandler(methodKey,
828                                            repositoryId, folderId, fileEntryTypeId, start, end);
829    
830                            Object returnObj = null;
831    
832                            try {
833                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
834                            }
835                            catch (Exception e) {
836                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
837                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
838                                    }
839    
840                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
841                            }
842    
843                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
844                    }
845                    catch (com.liferay.portal.kernel.exception.SystemException se) {
846                            _log.error(se, se);
847    
848                            throw se;
849                    }
850            }
851    
852            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
853                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
854                    long fileEntryTypeId, int start, int end,
855                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
856                    throws com.liferay.portal.kernel.exception.PortalException {
857                    try {
858                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
859                                            "getFileEntries", _getFileEntriesParameterTypes25);
860    
861                            MethodHandler methodHandler = new MethodHandler(methodKey,
862                                            repositoryId, folderId, fileEntryTypeId, start, end, obc);
863    
864                            Object returnObj = null;
865    
866                            try {
867                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
868                            }
869                            catch (Exception e) {
870                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
871                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
872                                    }
873    
874                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
875                            }
876    
877                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
878                    }
879                    catch (com.liferay.portal.kernel.exception.SystemException se) {
880                            _log.error(se, se);
881    
882                            throw se;
883                    }
884            }
885    
886            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
887                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
888                    java.lang.String[] mimeTypes)
889                    throws com.liferay.portal.kernel.exception.PortalException {
890                    try {
891                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
892                                            "getFileEntries", _getFileEntriesParameterTypes26);
893    
894                            MethodHandler methodHandler = new MethodHandler(methodKey,
895                                            repositoryId, folderId, mimeTypes);
896    
897                            Object returnObj = null;
898    
899                            try {
900                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
901                            }
902                            catch (Exception e) {
903                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
904                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
905                                    }
906    
907                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
908                            }
909    
910                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
911                    }
912                    catch (com.liferay.portal.kernel.exception.SystemException se) {
913                            _log.error(se, se);
914    
915                            throw se;
916                    }
917            }
918    
919            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getFileEntries(
920                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
921                    java.lang.String[] mimeTypes, int start, int end,
922                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
923                    throws com.liferay.portal.kernel.exception.PortalException {
924                    try {
925                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
926                                            "getFileEntries", _getFileEntriesParameterTypes27);
927    
928                            MethodHandler methodHandler = new MethodHandler(methodKey,
929                                            repositoryId, folderId, mimeTypes, start, end, obc);
930    
931                            Object returnObj = null;
932    
933                            try {
934                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
935                            }
936                            catch (Exception e) {
937                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
938                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
939                                    }
940    
941                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
942                            }
943    
944                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
945                    }
946                    catch (com.liferay.portal.kernel.exception.SystemException se) {
947                            _log.error(se, se);
948    
949                            throw se;
950                    }
951            }
952    
953            public static java.util.List<java.lang.Object> getFileEntriesAndFileShortcuts(
954                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
955                    int status, int start, int end)
956                    throws com.liferay.portal.kernel.exception.PortalException {
957                    try {
958                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
959                                            "getFileEntriesAndFileShortcuts",
960                                            _getFileEntriesAndFileShortcutsParameterTypes28);
961    
962                            MethodHandler methodHandler = new MethodHandler(methodKey,
963                                            repositoryId, folderId, status, start, end);
964    
965                            Object returnObj = null;
966    
967                            try {
968                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
969                            }
970                            catch (Exception e) {
971                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
972                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
973                                    }
974    
975                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
976                            }
977    
978                            return (java.util.List<java.lang.Object>)returnObj;
979                    }
980                    catch (com.liferay.portal.kernel.exception.SystemException se) {
981                            _log.error(se, se);
982    
983                            throw se;
984                    }
985            }
986    
987            public static int getFileEntriesAndFileShortcutsCount(
988                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
989                    int status) throws com.liferay.portal.kernel.exception.PortalException {
990                    try {
991                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
992                                            "getFileEntriesAndFileShortcutsCount",
993                                            _getFileEntriesAndFileShortcutsCountParameterTypes29);
994    
995                            MethodHandler methodHandler = new MethodHandler(methodKey,
996                                            repositoryId, folderId, status);
997    
998                            Object returnObj = null;
999    
1000                            try {
1001                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1002                            }
1003                            catch (Exception e) {
1004                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1005                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1006                                    }
1007    
1008                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1009                            }
1010    
1011                            return ((Integer)returnObj).intValue();
1012                    }
1013                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1014                            _log.error(se, se);
1015    
1016                            throw se;
1017                    }
1018            }
1019    
1020            public static int getFileEntriesAndFileShortcutsCount(
1021                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
1022                    int status, java.lang.String[] mimeTypes)
1023                    throws com.liferay.portal.kernel.exception.PortalException {
1024                    try {
1025                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1026                                            "getFileEntriesAndFileShortcutsCount",
1027                                            _getFileEntriesAndFileShortcutsCountParameterTypes30);
1028    
1029                            MethodHandler methodHandler = new MethodHandler(methodKey,
1030                                            repositoryId, folderId, status, mimeTypes);
1031    
1032                            Object returnObj = null;
1033    
1034                            try {
1035                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1036                            }
1037                            catch (Exception e) {
1038                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1039                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1040                                    }
1041    
1042                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1043                            }
1044    
1045                            return ((Integer)returnObj).intValue();
1046                    }
1047                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1048                            _log.error(se, se);
1049    
1050                            throw se;
1051                    }
1052            }
1053    
1054            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
1055                    long repositoryId, long folderId)
1056                    throws com.liferay.portal.kernel.exception.PortalException {
1057                    try {
1058                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1059                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes31);
1060    
1061                            MethodHandler methodHandler = new MethodHandler(methodKey,
1062                                            repositoryId, folderId);
1063    
1064                            Object returnObj = null;
1065    
1066                            try {
1067                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1068                            }
1069                            catch (Exception e) {
1070                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1071                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1072                                    }
1073    
1074                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1075                            }
1076    
1077                            return ((Integer)returnObj).intValue();
1078                    }
1079                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1080                            _log.error(se, se);
1081    
1082                            throw se;
1083                    }
1084            }
1085    
1086            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
1087                    long repositoryId, long folderId, long fileEntryTypeId)
1088                    throws com.liferay.portal.kernel.exception.PortalException {
1089                    try {
1090                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1091                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes32);
1092    
1093                            MethodHandler methodHandler = new MethodHandler(methodKey,
1094                                            repositoryId, folderId, fileEntryTypeId);
1095    
1096                            Object returnObj = null;
1097    
1098                            try {
1099                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1100                            }
1101                            catch (Exception e) {
1102                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1103                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1104                                    }
1105    
1106                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1107                            }
1108    
1109                            return ((Integer)returnObj).intValue();
1110                    }
1111                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1112                            _log.error(se, se);
1113    
1114                            throw se;
1115                    }
1116            }
1117    
1118            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
1119                    long repositoryId, long folderId, java.lang.String[] mimeTypes)
1120                    throws com.liferay.portal.kernel.exception.PortalException {
1121                    try {
1122                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1123                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes33);
1124    
1125                            MethodHandler methodHandler = new MethodHandler(methodKey,
1126                                            repositoryId, folderId, mimeTypes);
1127    
1128                            Object returnObj = null;
1129    
1130                            try {
1131                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1132                            }
1133                            catch (Exception e) {
1134                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1135                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1136                                    }
1137    
1138                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1139                            }
1140    
1141                            return ((Integer)returnObj).intValue();
1142                    }
1143                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1144                            _log.error(se, se);
1145    
1146                            throw se;
1147                    }
1148            }
1149    
1150            public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntry(
1151                    HttpPrincipal httpPrincipal, long fileEntryId)
1152                    throws com.liferay.portal.kernel.exception.PortalException {
1153                    try {
1154                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1155                                            "getFileEntry", _getFileEntryParameterTypes34);
1156    
1157                            MethodHandler methodHandler = new MethodHandler(methodKey,
1158                                            fileEntryId);
1159    
1160                            Object returnObj = null;
1161    
1162                            try {
1163                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1164                            }
1165                            catch (Exception e) {
1166                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1167                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1168                                    }
1169    
1170                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1171                            }
1172    
1173                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
1174                    }
1175                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1176                            _log.error(se, se);
1177    
1178                            throw se;
1179                    }
1180            }
1181    
1182            public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntry(
1183                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1184                    java.lang.String title)
1185                    throws com.liferay.portal.kernel.exception.PortalException {
1186                    try {
1187                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1188                                            "getFileEntry", _getFileEntryParameterTypes35);
1189    
1190                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1191                                            folderId, title);
1192    
1193                            Object returnObj = null;
1194    
1195                            try {
1196                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1197                            }
1198                            catch (Exception e) {
1199                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1200                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1201                                    }
1202    
1203                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1204                            }
1205    
1206                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
1207                    }
1208                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1209                            _log.error(se, se);
1210    
1211                            throw se;
1212                    }
1213            }
1214    
1215            public static com.liferay.portal.kernel.repository.model.FileEntry getFileEntryByUuidAndGroupId(
1216                    HttpPrincipal httpPrincipal, java.lang.String uuid, long groupId)
1217                    throws com.liferay.portal.kernel.exception.PortalException {
1218                    try {
1219                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1220                                            "getFileEntryByUuidAndGroupId",
1221                                            _getFileEntryByUuidAndGroupIdParameterTypes36);
1222    
1223                            MethodHandler methodHandler = new MethodHandler(methodKey, uuid,
1224                                            groupId);
1225    
1226                            Object returnObj = null;
1227    
1228                            try {
1229                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1230                            }
1231                            catch (Exception e) {
1232                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1233                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1234                                    }
1235    
1236                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1237                            }
1238    
1239                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
1240                    }
1241                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1242                            _log.error(se, se);
1243    
1244                            throw se;
1245                    }
1246            }
1247    
1248            public static com.liferay.portal.kernel.repository.model.FileShortcut getFileShortcut(
1249                    HttpPrincipal httpPrincipal, long fileShortcutId)
1250                    throws com.liferay.portal.kernel.exception.PortalException {
1251                    try {
1252                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1253                                            "getFileShortcut", _getFileShortcutParameterTypes37);
1254    
1255                            MethodHandler methodHandler = new MethodHandler(methodKey,
1256                                            fileShortcutId);
1257    
1258                            Object returnObj = null;
1259    
1260                            try {
1261                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1262                            }
1263                            catch (Exception e) {
1264                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1265                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1266                                    }
1267    
1268                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1269                            }
1270    
1271                            return (com.liferay.portal.kernel.repository.model.FileShortcut)returnObj;
1272                    }
1273                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1274                            _log.error(se, se);
1275    
1276                            throw se;
1277                    }
1278            }
1279    
1280            public static com.liferay.portal.kernel.repository.model.FileVersion getFileVersion(
1281                    HttpPrincipal httpPrincipal, long fileVersionId)
1282                    throws com.liferay.portal.kernel.exception.PortalException {
1283                    try {
1284                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1285                                            "getFileVersion", _getFileVersionParameterTypes38);
1286    
1287                            MethodHandler methodHandler = new MethodHandler(methodKey,
1288                                            fileVersionId);
1289    
1290                            Object returnObj = null;
1291    
1292                            try {
1293                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1294                            }
1295                            catch (Exception e) {
1296                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1297                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1298                                    }
1299    
1300                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1301                            }
1302    
1303                            return (com.liferay.portal.kernel.repository.model.FileVersion)returnObj;
1304                    }
1305                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1306                            _log.error(se, se);
1307    
1308                            throw se;
1309                    }
1310            }
1311    
1312            public static com.liferay.portal.kernel.repository.model.Folder getFolder(
1313                    HttpPrincipal httpPrincipal, long folderId)
1314                    throws com.liferay.portal.kernel.exception.PortalException {
1315                    try {
1316                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1317                                            "getFolder", _getFolderParameterTypes39);
1318    
1319                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
1320    
1321                            Object returnObj = null;
1322    
1323                            try {
1324                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1325                            }
1326                            catch (Exception e) {
1327                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1328                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1329                                    }
1330    
1331                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1332                            }
1333    
1334                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
1335                    }
1336                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1337                            _log.error(se, se);
1338    
1339                            throw se;
1340                    }
1341            }
1342    
1343            public static com.liferay.portal.kernel.repository.model.Folder getFolder(
1344                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1345                    java.lang.String name)
1346                    throws com.liferay.portal.kernel.exception.PortalException {
1347                    try {
1348                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1349                                            "getFolder", _getFolderParameterTypes40);
1350    
1351                            MethodHandler methodHandler = new MethodHandler(methodKey,
1352                                            repositoryId, parentFolderId, name);
1353    
1354                            Object returnObj = null;
1355    
1356                            try {
1357                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1358                            }
1359                            catch (Exception e) {
1360                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1361                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1362                                    }
1363    
1364                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1365                            }
1366    
1367                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
1368                    }
1369                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1370                            _log.error(se, se);
1371    
1372                            throw se;
1373                    }
1374            }
1375    
1376            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1377                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId)
1378                    throws com.liferay.portal.kernel.exception.PortalException {
1379                    try {
1380                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1381                                            "getFolders", _getFoldersParameterTypes41);
1382    
1383                            MethodHandler methodHandler = new MethodHandler(methodKey,
1384                                            repositoryId, parentFolderId);
1385    
1386                            Object returnObj = null;
1387    
1388                            try {
1389                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1390                            }
1391                            catch (Exception e) {
1392                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1393                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1394                                    }
1395    
1396                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1397                            }
1398    
1399                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1400                    }
1401                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1402                            _log.error(se, se);
1403    
1404                            throw se;
1405                    }
1406            }
1407    
1408            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1409                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1410                    boolean includeMountFolders)
1411                    throws com.liferay.portal.kernel.exception.PortalException {
1412                    try {
1413                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1414                                            "getFolders", _getFoldersParameterTypes42);
1415    
1416                            MethodHandler methodHandler = new MethodHandler(methodKey,
1417                                            repositoryId, parentFolderId, includeMountFolders);
1418    
1419                            Object returnObj = null;
1420    
1421                            try {
1422                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1423                            }
1424                            catch (Exception e) {
1425                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1426                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1427                                    }
1428    
1429                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1430                            }
1431    
1432                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1433                    }
1434                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1435                            _log.error(se, se);
1436    
1437                            throw se;
1438                    }
1439            }
1440    
1441            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1442                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1443                    boolean includeMountFolders, int start, int end)
1444                    throws com.liferay.portal.kernel.exception.PortalException {
1445                    try {
1446                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1447                                            "getFolders", _getFoldersParameterTypes43);
1448    
1449                            MethodHandler methodHandler = new MethodHandler(methodKey,
1450                                            repositoryId, parentFolderId, includeMountFolders, start,
1451                                            end);
1452    
1453                            Object returnObj = null;
1454    
1455                            try {
1456                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1457                            }
1458                            catch (Exception e) {
1459                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1460                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1461                                    }
1462    
1463                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1464                            }
1465    
1466                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1467                    }
1468                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1469                            _log.error(se, se);
1470    
1471                            throw se;
1472                    }
1473            }
1474    
1475            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1476                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1477                    boolean includeMountFolders, int start, int end,
1478                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1479                    throws com.liferay.portal.kernel.exception.PortalException {
1480                    try {
1481                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1482                                            "getFolders", _getFoldersParameterTypes44);
1483    
1484                            MethodHandler methodHandler = new MethodHandler(methodKey,
1485                                            repositoryId, parentFolderId, includeMountFolders, start,
1486                                            end, obc);
1487    
1488                            Object returnObj = null;
1489    
1490                            try {
1491                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1492                            }
1493                            catch (Exception e) {
1494                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1495                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1496                                    }
1497    
1498                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1499                            }
1500    
1501                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1502                    }
1503                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1504                            _log.error(se, se);
1505    
1506                            throw se;
1507                    }
1508            }
1509    
1510            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1511                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1512                    int status, boolean includeMountFolders, int start, int end,
1513                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1514                    throws com.liferay.portal.kernel.exception.PortalException {
1515                    try {
1516                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1517                                            "getFolders", _getFoldersParameterTypes45);
1518    
1519                            MethodHandler methodHandler = new MethodHandler(methodKey,
1520                                            repositoryId, parentFolderId, status, includeMountFolders,
1521                                            start, end, obc);
1522    
1523                            Object returnObj = null;
1524    
1525                            try {
1526                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1527                            }
1528                            catch (Exception e) {
1529                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1530                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1531                                    }
1532    
1533                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1534                            }
1535    
1536                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1537                    }
1538                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1539                            _log.error(se, se);
1540    
1541                            throw se;
1542                    }
1543            }
1544    
1545            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1546                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1547                    int start, int end)
1548                    throws com.liferay.portal.kernel.exception.PortalException {
1549                    try {
1550                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1551                                            "getFolders", _getFoldersParameterTypes46);
1552    
1553                            MethodHandler methodHandler = new MethodHandler(methodKey,
1554                                            repositoryId, parentFolderId, start, end);
1555    
1556                            Object returnObj = null;
1557    
1558                            try {
1559                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1560                            }
1561                            catch (Exception e) {
1562                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1563                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1564                                    }
1565    
1566                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1567                            }
1568    
1569                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1570                    }
1571                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1572                            _log.error(se, se);
1573    
1574                            throw se;
1575                    }
1576            }
1577    
1578            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getFolders(
1579                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
1580                    int start, int end,
1581                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
1582                    throws com.liferay.portal.kernel.exception.PortalException {
1583                    try {
1584                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1585                                            "getFolders", _getFoldersParameterTypes47);
1586    
1587                            MethodHandler methodHandler = new MethodHandler(methodKey,
1588                                            repositoryId, parentFolderId, start, end, obc);
1589    
1590                            Object returnObj = null;
1591    
1592                            try {
1593                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1594                            }
1595                            catch (Exception e) {
1596                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1597                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1598                                    }
1599    
1600                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1601                            }
1602    
1603                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
1604                    }
1605                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1606                            _log.error(se, se);
1607    
1608                            throw se;
1609                    }
1610            }
1611    
1612            public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts(
1613                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
1614                    int status, boolean includeMountFolders, int start, int end)
1615                    throws com.liferay.portal.kernel.exception.PortalException {
1616                    try {
1617                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1618                                            "getFoldersAndFileEntriesAndFileShortcuts",
1619                                            _getFoldersAndFileEntriesAndFileShortcutsParameterTypes48);
1620    
1621                            MethodHandler methodHandler = new MethodHandler(methodKey,
1622                                            repositoryId, folderId, status, includeMountFolders, start,
1623                                            end);
1624    
1625                            Object returnObj = null;
1626    
1627                            try {
1628                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1629                            }
1630                            catch (Exception e) {
1631                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1632                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1633                                    }
1634    
1635                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1636                            }
1637    
1638                            return (java.util.List<java.lang.Object>)returnObj;
1639                    }
1640                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1641                            _log.error(se, se);
1642    
1643                            throw se;
1644                    }
1645            }
1646    
1647            public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts(
1648                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
1649                    int status, boolean includeMountFolders, int start, int end,
1650                    com.liferay.portal.kernel.util.OrderByComparator<?> obc)
1651                    throws com.liferay.portal.kernel.exception.PortalException {
1652                    try {
1653                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1654                                            "getFoldersAndFileEntriesAndFileShortcuts",
1655                                            _getFoldersAndFileEntriesAndFileShortcutsParameterTypes49);
1656    
1657                            MethodHandler methodHandler = new MethodHandler(methodKey,
1658                                            repositoryId, folderId, status, includeMountFolders, start,
1659                                            end, obc);
1660    
1661                            Object returnObj = null;
1662    
1663                            try {
1664                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1665                            }
1666                            catch (Exception e) {
1667                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1668                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1669                                    }
1670    
1671                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1672                            }
1673    
1674                            return (java.util.List<java.lang.Object>)returnObj;
1675                    }
1676                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1677                            _log.error(se, se);
1678    
1679                            throw se;
1680                    }
1681            }
1682    
1683            public static java.util.List<java.lang.Object> getFoldersAndFileEntriesAndFileShortcuts(
1684                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
1685                    int status, java.lang.String[] mimeTypes, boolean includeMountFolders,
1686                    int start, int end,
1687                    com.liferay.portal.kernel.util.OrderByComparator<?> obc)
1688                    throws com.liferay.portal.kernel.exception.PortalException {
1689                    try {
1690                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1691                                            "getFoldersAndFileEntriesAndFileShortcuts",
1692                                            _getFoldersAndFileEntriesAndFileShortcutsParameterTypes50);
1693    
1694                            MethodHandler methodHandler = new MethodHandler(methodKey,
1695                                            repositoryId, folderId, status, mimeTypes,
1696                                            includeMountFolders, start, end, obc);
1697    
1698                            Object returnObj = null;
1699    
1700                            try {
1701                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1702                            }
1703                            catch (Exception e) {
1704                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1705                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1706                                    }
1707    
1708                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1709                            }
1710    
1711                            return (java.util.List<java.lang.Object>)returnObj;
1712                    }
1713                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1714                            _log.error(se, se);
1715    
1716                            throw se;
1717                    }
1718            }
1719    
1720            public static int getFoldersAndFileEntriesAndFileShortcutsCount(
1721                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
1722                    int status, boolean includeMountFolders)
1723                    throws com.liferay.portal.kernel.exception.PortalException {
1724                    try {
1725                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1726                                            "getFoldersAndFileEntriesAndFileShortcutsCount",
1727                                            _getFoldersAndFileEntriesAndFileShortcutsCountParameterTypes51);
1728    
1729                            MethodHandler methodHandler = new MethodHandler(methodKey,
1730                                            repositoryId, folderId, status, includeMountFolders);
1731    
1732                            Object returnObj = null;
1733    
1734                            try {
1735                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1736                            }
1737                            catch (Exception e) {
1738                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1739                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1740                                    }
1741    
1742                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1743                            }
1744    
1745                            return ((Integer)returnObj).intValue();
1746                    }
1747                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1748                            _log.error(se, se);
1749    
1750                            throw se;
1751                    }
1752            }
1753    
1754            public static int getFoldersAndFileEntriesAndFileShortcutsCount(
1755                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
1756                    int status, java.lang.String[] mimeTypes, boolean includeMountFolders)
1757                    throws com.liferay.portal.kernel.exception.PortalException {
1758                    try {
1759                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1760                                            "getFoldersAndFileEntriesAndFileShortcutsCount",
1761                                            _getFoldersAndFileEntriesAndFileShortcutsCountParameterTypes52);
1762    
1763                            MethodHandler methodHandler = new MethodHandler(methodKey,
1764                                            repositoryId, folderId, status, mimeTypes,
1765                                            includeMountFolders);
1766    
1767                            Object returnObj = null;
1768    
1769                            try {
1770                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1771                            }
1772                            catch (Exception e) {
1773                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1774                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1775                                    }
1776    
1777                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1778                            }
1779    
1780                            return ((Integer)returnObj).intValue();
1781                    }
1782                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1783                            _log.error(se, se);
1784    
1785                            throw se;
1786                    }
1787            }
1788    
1789            public static int getFoldersCount(HttpPrincipal httpPrincipal,
1790                    long repositoryId, long parentFolderId)
1791                    throws com.liferay.portal.kernel.exception.PortalException {
1792                    try {
1793                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1794                                            "getFoldersCount", _getFoldersCountParameterTypes53);
1795    
1796                            MethodHandler methodHandler = new MethodHandler(methodKey,
1797                                            repositoryId, parentFolderId);
1798    
1799                            Object returnObj = null;
1800    
1801                            try {
1802                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1803                            }
1804                            catch (Exception e) {
1805                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1806                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1807                                    }
1808    
1809                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1810                            }
1811    
1812                            return ((Integer)returnObj).intValue();
1813                    }
1814                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1815                            _log.error(se, se);
1816    
1817                            throw se;
1818                    }
1819            }
1820    
1821            public static int getFoldersCount(HttpPrincipal httpPrincipal,
1822                    long repositoryId, long parentFolderId, boolean includeMountFolders)
1823                    throws com.liferay.portal.kernel.exception.PortalException {
1824                    try {
1825                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1826                                            "getFoldersCount", _getFoldersCountParameterTypes54);
1827    
1828                            MethodHandler methodHandler = new MethodHandler(methodKey,
1829                                            repositoryId, parentFolderId, includeMountFolders);
1830    
1831                            Object returnObj = null;
1832    
1833                            try {
1834                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1835                            }
1836                            catch (Exception e) {
1837                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1838                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1839                                    }
1840    
1841                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1842                            }
1843    
1844                            return ((Integer)returnObj).intValue();
1845                    }
1846                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1847                            _log.error(se, se);
1848    
1849                            throw se;
1850                    }
1851            }
1852    
1853            public static int getFoldersCount(HttpPrincipal httpPrincipal,
1854                    long repositoryId, long parentFolderId, int status,
1855                    boolean includeMountFolders)
1856                    throws com.liferay.portal.kernel.exception.PortalException {
1857                    try {
1858                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1859                                            "getFoldersCount", _getFoldersCountParameterTypes55);
1860    
1861                            MethodHandler methodHandler = new MethodHandler(methodKey,
1862                                            repositoryId, parentFolderId, status, includeMountFolders);
1863    
1864                            Object returnObj = null;
1865    
1866                            try {
1867                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1868                            }
1869                            catch (Exception e) {
1870                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1871                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1872                                    }
1873    
1874                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1875                            }
1876    
1877                            return ((Integer)returnObj).intValue();
1878                    }
1879                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1880                            _log.error(se, se);
1881    
1882                            throw se;
1883                    }
1884            }
1885    
1886            public static int getFoldersFileEntriesCount(HttpPrincipal httpPrincipal,
1887                    long repositoryId, java.util.List<java.lang.Long> folderIds, int status)
1888                    throws com.liferay.portal.kernel.exception.PortalException {
1889                    try {
1890                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1891                                            "getFoldersFileEntriesCount",
1892                                            _getFoldersFileEntriesCountParameterTypes56);
1893    
1894                            MethodHandler methodHandler = new MethodHandler(methodKey,
1895                                            repositoryId, folderIds, status);
1896    
1897                            Object returnObj = null;
1898    
1899                            try {
1900                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1901                            }
1902                            catch (Exception e) {
1903                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1904                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1905                                    }
1906    
1907                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1908                            }
1909    
1910                            return ((Integer)returnObj).intValue();
1911                    }
1912                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1913                            _log.error(se, se);
1914    
1915                            throw se;
1916                    }
1917            }
1918    
1919            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1920                    HttpPrincipal httpPrincipal, long groupId, long userId, int start,
1921                    int end) throws com.liferay.portal.kernel.exception.PortalException {
1922                    try {
1923                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1924                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes57);
1925    
1926                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1927                                            userId, start, end);
1928    
1929                            Object returnObj = null;
1930    
1931                            try {
1932                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1933                            }
1934                            catch (Exception e) {
1935                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1936                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1937                                    }
1938    
1939                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1940                            }
1941    
1942                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
1943                    }
1944                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1945                            _log.error(se, se);
1946    
1947                            throw se;
1948                    }
1949            }
1950    
1951            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1952                    HttpPrincipal httpPrincipal, long groupId, long userId, int start,
1953                    int end,
1954                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
1955                    throws com.liferay.portal.kernel.exception.PortalException {
1956                    try {
1957                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1958                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes58);
1959    
1960                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1961                                            userId, start, end, obc);
1962    
1963                            Object returnObj = null;
1964    
1965                            try {
1966                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1967                            }
1968                            catch (Exception e) {
1969                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1970                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1971                                    }
1972    
1973                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1974                            }
1975    
1976                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
1977                    }
1978                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1979                            _log.error(se, se);
1980    
1981                            throw se;
1982                    }
1983            }
1984    
1985            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
1986                    HttpPrincipal httpPrincipal, long groupId, long userId,
1987                    long rootFolderId, int start, int end)
1988                    throws com.liferay.portal.kernel.exception.PortalException {
1989                    try {
1990                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
1991                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes59);
1992    
1993                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1994                                            userId, rootFolderId, start, end);
1995    
1996                            Object returnObj = null;
1997    
1998                            try {
1999                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2000                            }
2001                            catch (Exception e) {
2002                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2003                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2004                                    }
2005    
2006                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2007                            }
2008    
2009                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
2010                    }
2011                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2012                            _log.error(se, se);
2013    
2014                            throw se;
2015                    }
2016            }
2017    
2018            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
2019                    HttpPrincipal httpPrincipal, long groupId, long userId,
2020                    long rootFolderId, int start, int end,
2021                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
2022                    throws com.liferay.portal.kernel.exception.PortalException {
2023                    try {
2024                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2025                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes60);
2026    
2027                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2028                                            userId, rootFolderId, start, end, obc);
2029    
2030                            Object returnObj = null;
2031    
2032                            try {
2033                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2034                            }
2035                            catch (Exception e) {
2036                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2037                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2038                                    }
2039    
2040                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2041                            }
2042    
2043                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
2044                    }
2045                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2046                            _log.error(se, se);
2047    
2048                            throw se;
2049                    }
2050            }
2051    
2052            public static java.util.List<com.liferay.portal.kernel.repository.model.FileEntry> getGroupFileEntries(
2053                    HttpPrincipal httpPrincipal, long groupId, long userId,
2054                    long rootFolderId, java.lang.String[] mimeTypes, int status, int start,
2055                    int end,
2056                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.FileEntry> obc)
2057                    throws com.liferay.portal.kernel.exception.PortalException {
2058                    try {
2059                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2060                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes61);
2061    
2062                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2063                                            userId, rootFolderId, mimeTypes, status, start, end, obc);
2064    
2065                            Object returnObj = null;
2066    
2067                            try {
2068                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2069                            }
2070                            catch (Exception e) {
2071                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2072                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2073                                    }
2074    
2075                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2076                            }
2077    
2078                            return (java.util.List<com.liferay.portal.kernel.repository.model.FileEntry>)returnObj;
2079                    }
2080                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2081                            _log.error(se, se);
2082    
2083                            throw se;
2084                    }
2085            }
2086    
2087            public static int getGroupFileEntriesCount(HttpPrincipal httpPrincipal,
2088                    long groupId, long userId)
2089                    throws com.liferay.portal.kernel.exception.PortalException {
2090                    try {
2091                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2092                                            "getGroupFileEntriesCount",
2093                                            _getGroupFileEntriesCountParameterTypes62);
2094    
2095                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2096                                            userId);
2097    
2098                            Object returnObj = null;
2099    
2100                            try {
2101                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2102                            }
2103                            catch (Exception e) {
2104                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2105                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2106                                    }
2107    
2108                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2109                            }
2110    
2111                            return ((Integer)returnObj).intValue();
2112                    }
2113                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2114                            _log.error(se, se);
2115    
2116                            throw se;
2117                    }
2118            }
2119    
2120            public static int getGroupFileEntriesCount(HttpPrincipal httpPrincipal,
2121                    long groupId, long userId, long rootFolderId)
2122                    throws com.liferay.portal.kernel.exception.PortalException {
2123                    try {
2124                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2125                                            "getGroupFileEntriesCount",
2126                                            _getGroupFileEntriesCountParameterTypes63);
2127    
2128                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2129                                            userId, rootFolderId);
2130    
2131                            Object returnObj = null;
2132    
2133                            try {
2134                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2135                            }
2136                            catch (Exception e) {
2137                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2138                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2139                                    }
2140    
2141                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2142                            }
2143    
2144                            return ((Integer)returnObj).intValue();
2145                    }
2146                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2147                            _log.error(se, se);
2148    
2149                            throw se;
2150                    }
2151            }
2152    
2153            public static int getGroupFileEntriesCount(HttpPrincipal httpPrincipal,
2154                    long groupId, long userId, long rootFolderId,
2155                    java.lang.String[] mimeTypes, int status)
2156                    throws com.liferay.portal.kernel.exception.PortalException {
2157                    try {
2158                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2159                                            "getGroupFileEntriesCount",
2160                                            _getGroupFileEntriesCountParameterTypes64);
2161    
2162                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2163                                            userId, rootFolderId, mimeTypes, status);
2164    
2165                            Object returnObj = null;
2166    
2167                            try {
2168                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2169                            }
2170                            catch (Exception e) {
2171                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2172                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2173                                    }
2174    
2175                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2176                            }
2177    
2178                            return ((Integer)returnObj).intValue();
2179                    }
2180                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2181                            _log.error(se, se);
2182    
2183                            throw se;
2184                    }
2185            }
2186    
2187            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders(
2188                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId)
2189                    throws com.liferay.portal.kernel.exception.PortalException {
2190                    try {
2191                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2192                                            "getMountFolders", _getMountFoldersParameterTypes65);
2193    
2194                            MethodHandler methodHandler = new MethodHandler(methodKey,
2195                                            repositoryId, parentFolderId);
2196    
2197                            Object returnObj = null;
2198    
2199                            try {
2200                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2201                            }
2202                            catch (Exception e) {
2203                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2204                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2205                                    }
2206    
2207                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2208                            }
2209    
2210                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
2211                    }
2212                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2213                            _log.error(se, se);
2214    
2215                            throw se;
2216                    }
2217            }
2218    
2219            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders(
2220                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
2221                    int start, int end)
2222                    throws com.liferay.portal.kernel.exception.PortalException {
2223                    try {
2224                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2225                                            "getMountFolders", _getMountFoldersParameterTypes66);
2226    
2227                            MethodHandler methodHandler = new MethodHandler(methodKey,
2228                                            repositoryId, parentFolderId, start, end);
2229    
2230                            Object returnObj = null;
2231    
2232                            try {
2233                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2234                            }
2235                            catch (Exception e) {
2236                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2237                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2238                                    }
2239    
2240                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2241                            }
2242    
2243                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
2244                    }
2245                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2246                            _log.error(se, se);
2247    
2248                            throw se;
2249                    }
2250            }
2251    
2252            public static java.util.List<com.liferay.portal.kernel.repository.model.Folder> getMountFolders(
2253                    HttpPrincipal httpPrincipal, long repositoryId, long parentFolderId,
2254                    int start, int end,
2255                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.repository.model.Folder> obc)
2256                    throws com.liferay.portal.kernel.exception.PortalException {
2257                    try {
2258                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2259                                            "getMountFolders", _getMountFoldersParameterTypes67);
2260    
2261                            MethodHandler methodHandler = new MethodHandler(methodKey,
2262                                            repositoryId, parentFolderId, start, end, obc);
2263    
2264                            Object returnObj = null;
2265    
2266                            try {
2267                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2268                            }
2269                            catch (Exception e) {
2270                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2271                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2272                                    }
2273    
2274                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2275                            }
2276    
2277                            return (java.util.List<com.liferay.portal.kernel.repository.model.Folder>)returnObj;
2278                    }
2279                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2280                            _log.error(se, se);
2281    
2282                            throw se;
2283                    }
2284            }
2285    
2286            public static int getMountFoldersCount(HttpPrincipal httpPrincipal,
2287                    long repositoryId, long parentFolderId)
2288                    throws com.liferay.portal.kernel.exception.PortalException {
2289                    try {
2290                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2291                                            "getMountFoldersCount",
2292                                            _getMountFoldersCountParameterTypes68);
2293    
2294                            MethodHandler methodHandler = new MethodHandler(methodKey,
2295                                            repositoryId, parentFolderId);
2296    
2297                            Object returnObj = null;
2298    
2299                            try {
2300                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2301                            }
2302                            catch (Exception e) {
2303                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2304                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2305                                    }
2306    
2307                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2308                            }
2309    
2310                            return ((Integer)returnObj).intValue();
2311                    }
2312                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2313                            _log.error(se, se);
2314    
2315                            throw se;
2316                    }
2317            }
2318    
2319            public static void getSubfolderIds(HttpPrincipal httpPrincipal,
2320                    long repositoryId, java.util.List<java.lang.Long> folderIds,
2321                    long folderId)
2322                    throws com.liferay.portal.kernel.exception.PortalException {
2323                    try {
2324                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2325                                            "getSubfolderIds", _getSubfolderIdsParameterTypes69);
2326    
2327                            MethodHandler methodHandler = new MethodHandler(methodKey,
2328                                            repositoryId, folderIds, folderId);
2329    
2330                            try {
2331                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2332                            }
2333                            catch (Exception e) {
2334                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2335                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2336                                    }
2337    
2338                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2339                            }
2340                    }
2341                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2342                            _log.error(se, se);
2343    
2344                            throw se;
2345                    }
2346            }
2347    
2348            public static java.util.List<java.lang.Long> getSubfolderIds(
2349                    HttpPrincipal httpPrincipal, long repositoryId, long folderId)
2350                    throws com.liferay.portal.kernel.exception.PortalException {
2351                    try {
2352                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2353                                            "getSubfolderIds", _getSubfolderIdsParameterTypes70);
2354    
2355                            MethodHandler methodHandler = new MethodHandler(methodKey,
2356                                            repositoryId, folderId);
2357    
2358                            Object returnObj = null;
2359    
2360                            try {
2361                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2362                            }
2363                            catch (Exception e) {
2364                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2365                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2366                                    }
2367    
2368                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2369                            }
2370    
2371                            return (java.util.List<java.lang.Long>)returnObj;
2372                    }
2373                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2374                            _log.error(se, se);
2375    
2376                            throw se;
2377                    }
2378            }
2379    
2380            public static java.util.List<java.lang.Long> getSubfolderIds(
2381                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
2382                    boolean recurse)
2383                    throws com.liferay.portal.kernel.exception.PortalException {
2384                    try {
2385                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2386                                            "getSubfolderIds", _getSubfolderIdsParameterTypes71);
2387    
2388                            MethodHandler methodHandler = new MethodHandler(methodKey,
2389                                            repositoryId, folderId, recurse);
2390    
2391                            Object returnObj = null;
2392    
2393                            try {
2394                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2395                            }
2396                            catch (Exception e) {
2397                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2398                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2399                                    }
2400    
2401                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2402                            }
2403    
2404                            return (java.util.List<java.lang.Long>)returnObj;
2405                    }
2406                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2407                            _log.error(se, se);
2408    
2409                            throw se;
2410                    }
2411            }
2412    
2413            public static java.lang.String[] getTempFileNames(
2414                    HttpPrincipal httpPrincipal, long groupId, long folderId,
2415                    java.lang.String folderName)
2416                    throws com.liferay.portal.kernel.exception.PortalException {
2417                    try {
2418                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2419                                            "getTempFileNames", _getTempFileNamesParameterTypes72);
2420    
2421                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2422                                            folderId, folderName);
2423    
2424                            Object returnObj = null;
2425    
2426                            try {
2427                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2428                            }
2429                            catch (Exception e) {
2430                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2431                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2432                                    }
2433    
2434                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2435                            }
2436    
2437                            return (java.lang.String[])returnObj;
2438                    }
2439                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2440                            _log.error(se, se);
2441    
2442                            throw se;
2443                    }
2444            }
2445    
2446            public static com.liferay.portal.kernel.lock.Lock lockFolder(
2447                    HttpPrincipal httpPrincipal, long repositoryId, long folderId)
2448                    throws com.liferay.portal.kernel.exception.PortalException {
2449                    try {
2450                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2451                                            "lockFolder", _lockFolderParameterTypes73);
2452    
2453                            MethodHandler methodHandler = new MethodHandler(methodKey,
2454                                            repositoryId, folderId);
2455    
2456                            Object returnObj = null;
2457    
2458                            try {
2459                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2460                            }
2461                            catch (Exception e) {
2462                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2463                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2464                                    }
2465    
2466                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2467                            }
2468    
2469                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
2470                    }
2471                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2472                            _log.error(se, se);
2473    
2474                            throw se;
2475                    }
2476            }
2477    
2478            public static com.liferay.portal.kernel.lock.Lock lockFolder(
2479                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
2480                    java.lang.String owner, boolean inheritable, long expirationTime)
2481                    throws com.liferay.portal.kernel.exception.PortalException {
2482                    try {
2483                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2484                                            "lockFolder", _lockFolderParameterTypes74);
2485    
2486                            MethodHandler methodHandler = new MethodHandler(methodKey,
2487                                            repositoryId, folderId, owner, inheritable, expirationTime);
2488    
2489                            Object returnObj = null;
2490    
2491                            try {
2492                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2493                            }
2494                            catch (Exception e) {
2495                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2496                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2497                                    }
2498    
2499                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2500                            }
2501    
2502                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
2503                    }
2504                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2505                            _log.error(se, se);
2506    
2507                            throw se;
2508                    }
2509            }
2510    
2511            public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntry(
2512                    HttpPrincipal httpPrincipal, long fileEntryId, long newFolderId,
2513                    com.liferay.portal.service.ServiceContext serviceContext)
2514                    throws com.liferay.portal.kernel.exception.PortalException {
2515                    try {
2516                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2517                                            "moveFileEntry", _moveFileEntryParameterTypes75);
2518    
2519                            MethodHandler methodHandler = new MethodHandler(methodKey,
2520                                            fileEntryId, newFolderId, serviceContext);
2521    
2522                            Object returnObj = null;
2523    
2524                            try {
2525                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2526                            }
2527                            catch (Exception e) {
2528                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2529                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2530                                    }
2531    
2532                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2533                            }
2534    
2535                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
2536                    }
2537                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2538                            _log.error(se, se);
2539    
2540                            throw se;
2541                    }
2542            }
2543    
2544            public static com.liferay.portal.kernel.repository.model.Folder moveFolder(
2545                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
2546                    com.liferay.portal.service.ServiceContext serviceContext)
2547                    throws com.liferay.portal.kernel.exception.PortalException {
2548                    try {
2549                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2550                                            "moveFolder", _moveFolderParameterTypes76);
2551    
2552                            MethodHandler methodHandler = new MethodHandler(methodKey,
2553                                            folderId, parentFolderId, serviceContext);
2554    
2555                            Object returnObj = null;
2556    
2557                            try {
2558                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2559                            }
2560                            catch (Exception e) {
2561                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2562                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2563                                    }
2564    
2565                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2566                            }
2567    
2568                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
2569                    }
2570                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2571                            _log.error(se, se);
2572    
2573                            throw se;
2574                    }
2575            }
2576    
2577            public static com.liferay.portal.kernel.lock.Lock refreshFileEntryLock(
2578                    HttpPrincipal httpPrincipal, java.lang.String lockUuid, long companyId,
2579                    long expirationTime)
2580                    throws com.liferay.portal.kernel.exception.PortalException {
2581                    try {
2582                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2583                                            "refreshFileEntryLock",
2584                                            _refreshFileEntryLockParameterTypes77);
2585    
2586                            MethodHandler methodHandler = new MethodHandler(methodKey,
2587                                            lockUuid, companyId, expirationTime);
2588    
2589                            Object returnObj = null;
2590    
2591                            try {
2592                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2593                            }
2594                            catch (Exception e) {
2595                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2596                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2597                                    }
2598    
2599                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2600                            }
2601    
2602                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
2603                    }
2604                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2605                            _log.error(se, se);
2606    
2607                            throw se;
2608                    }
2609            }
2610    
2611            public static com.liferay.portal.kernel.lock.Lock refreshFolderLock(
2612                    HttpPrincipal httpPrincipal, java.lang.String lockUuid, long companyId,
2613                    long expirationTime)
2614                    throws com.liferay.portal.kernel.exception.PortalException {
2615                    try {
2616                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2617                                            "refreshFolderLock", _refreshFolderLockParameterTypes78);
2618    
2619                            MethodHandler methodHandler = new MethodHandler(methodKey,
2620                                            lockUuid, companyId, expirationTime);
2621    
2622                            Object returnObj = null;
2623    
2624                            try {
2625                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2626                            }
2627                            catch (Exception e) {
2628                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2629                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2630                                    }
2631    
2632                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2633                            }
2634    
2635                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
2636                    }
2637                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2638                            _log.error(se, se);
2639    
2640                            throw se;
2641                    }
2642            }
2643    
2644            public static void revertFileEntry(HttpPrincipal httpPrincipal,
2645                    long fileEntryId, java.lang.String version,
2646                    com.liferay.portal.service.ServiceContext serviceContext)
2647                    throws com.liferay.portal.kernel.exception.PortalException {
2648                    try {
2649                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2650                                            "revertFileEntry", _revertFileEntryParameterTypes79);
2651    
2652                            MethodHandler methodHandler = new MethodHandler(methodKey,
2653                                            fileEntryId, version, serviceContext);
2654    
2655                            try {
2656                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2657                            }
2658                            catch (Exception e) {
2659                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2660                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2661                                    }
2662    
2663                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2664                            }
2665                    }
2666                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2667                            _log.error(se, se);
2668    
2669                            throw se;
2670                    }
2671            }
2672    
2673            public static com.liferay.portal.kernel.search.Hits search(
2674                    HttpPrincipal httpPrincipal, long repositoryId, long creatorUserId,
2675                    int status, int start, int end)
2676                    throws com.liferay.portal.kernel.exception.PortalException {
2677                    try {
2678                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2679                                            "search", _searchParameterTypes80);
2680    
2681                            MethodHandler methodHandler = new MethodHandler(methodKey,
2682                                            repositoryId, creatorUserId, status, start, end);
2683    
2684                            Object returnObj = null;
2685    
2686                            try {
2687                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2688                            }
2689                            catch (Exception e) {
2690                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2691                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2692                                    }
2693    
2694                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2695                            }
2696    
2697                            return (com.liferay.portal.kernel.search.Hits)returnObj;
2698                    }
2699                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2700                            _log.error(se, se);
2701    
2702                            throw se;
2703                    }
2704            }
2705    
2706            public static com.liferay.portal.kernel.search.Hits search(
2707                    HttpPrincipal httpPrincipal, long repositoryId, long creatorUserId,
2708                    long folderId, java.lang.String[] mimeTypes, int status, int start,
2709                    int end) throws com.liferay.portal.kernel.exception.PortalException {
2710                    try {
2711                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2712                                            "search", _searchParameterTypes81);
2713    
2714                            MethodHandler methodHandler = new MethodHandler(methodKey,
2715                                            repositoryId, creatorUserId, folderId, mimeTypes, status,
2716                                            start, end);
2717    
2718                            Object returnObj = null;
2719    
2720                            try {
2721                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2722                            }
2723                            catch (Exception e) {
2724                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2725                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2726                                    }
2727    
2728                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2729                            }
2730    
2731                            return (com.liferay.portal.kernel.search.Hits)returnObj;
2732                    }
2733                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2734                            _log.error(se, se);
2735    
2736                            throw se;
2737                    }
2738            }
2739    
2740            public static com.liferay.portal.kernel.search.Hits search(
2741                    HttpPrincipal httpPrincipal, long repositoryId,
2742                    com.liferay.portal.kernel.search.SearchContext searchContext)
2743                    throws com.liferay.portal.kernel.search.SearchException {
2744                    try {
2745                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2746                                            "search", _searchParameterTypes82);
2747    
2748                            MethodHandler methodHandler = new MethodHandler(methodKey,
2749                                            repositoryId, searchContext);
2750    
2751                            Object returnObj = null;
2752    
2753                            try {
2754                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2755                            }
2756                            catch (Exception e) {
2757                                    if (e instanceof com.liferay.portal.kernel.search.SearchException) {
2758                                            throw (com.liferay.portal.kernel.search.SearchException)e;
2759                                    }
2760    
2761                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2762                            }
2763    
2764                            return (com.liferay.portal.kernel.search.Hits)returnObj;
2765                    }
2766                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2767                            _log.error(se, se);
2768    
2769                            throw se;
2770                    }
2771            }
2772    
2773            public static com.liferay.portal.kernel.search.Hits search(
2774                    HttpPrincipal httpPrincipal, long repositoryId,
2775                    com.liferay.portal.kernel.search.SearchContext searchContext,
2776                    com.liferay.portal.kernel.search.Query query)
2777                    throws com.liferay.portal.kernel.search.SearchException {
2778                    try {
2779                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2780                                            "search", _searchParameterTypes83);
2781    
2782                            MethodHandler methodHandler = new MethodHandler(methodKey,
2783                                            repositoryId, searchContext, query);
2784    
2785                            Object returnObj = null;
2786    
2787                            try {
2788                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2789                            }
2790                            catch (Exception e) {
2791                                    if (e instanceof com.liferay.portal.kernel.search.SearchException) {
2792                                            throw (com.liferay.portal.kernel.search.SearchException)e;
2793                                    }
2794    
2795                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2796                            }
2797    
2798                            return (com.liferay.portal.kernel.search.Hits)returnObj;
2799                    }
2800                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2801                            _log.error(se, se);
2802    
2803                            throw se;
2804                    }
2805            }
2806    
2807            public static void subscribeFileEntryType(HttpPrincipal httpPrincipal,
2808                    long groupId, long fileEntryTypeId)
2809                    throws com.liferay.portal.kernel.exception.PortalException {
2810                    try {
2811                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2812                                            "subscribeFileEntryType",
2813                                            _subscribeFileEntryTypeParameterTypes84);
2814    
2815                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2816                                            fileEntryTypeId);
2817    
2818                            try {
2819                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2820                            }
2821                            catch (Exception e) {
2822                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2823                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2824                                    }
2825    
2826                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2827                            }
2828                    }
2829                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2830                            _log.error(se, se);
2831    
2832                            throw se;
2833                    }
2834            }
2835    
2836            public static void subscribeFolder(HttpPrincipal httpPrincipal,
2837                    long groupId, long folderId)
2838                    throws com.liferay.portal.kernel.exception.PortalException {
2839                    try {
2840                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2841                                            "subscribeFolder", _subscribeFolderParameterTypes85);
2842    
2843                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2844                                            folderId);
2845    
2846                            try {
2847                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2848                            }
2849                            catch (Exception e) {
2850                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2851                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2852                                    }
2853    
2854                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2855                            }
2856                    }
2857                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2858                            _log.error(se, se);
2859    
2860                            throw se;
2861                    }
2862            }
2863    
2864            public static void unlockFolder(HttpPrincipal httpPrincipal,
2865                    long repositoryId, long folderId, java.lang.String lockUuid)
2866                    throws com.liferay.portal.kernel.exception.PortalException {
2867                    try {
2868                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2869                                            "unlockFolder", _unlockFolderParameterTypes86);
2870    
2871                            MethodHandler methodHandler = new MethodHandler(methodKey,
2872                                            repositoryId, folderId, lockUuid);
2873    
2874                            try {
2875                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2876                            }
2877                            catch (Exception e) {
2878                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2879                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2880                                    }
2881    
2882                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2883                            }
2884                    }
2885                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2886                            _log.error(se, se);
2887    
2888                            throw se;
2889                    }
2890            }
2891    
2892            public static void unlockFolder(HttpPrincipal httpPrincipal,
2893                    long repositoryId, long parentFolderId, java.lang.String name,
2894                    java.lang.String lockUuid)
2895                    throws com.liferay.portal.kernel.exception.PortalException {
2896                    try {
2897                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2898                                            "unlockFolder", _unlockFolderParameterTypes87);
2899    
2900                            MethodHandler methodHandler = new MethodHandler(methodKey,
2901                                            repositoryId, parentFolderId, name, lockUuid);
2902    
2903                            try {
2904                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2905                            }
2906                            catch (Exception e) {
2907                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2908                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2909                                    }
2910    
2911                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2912                            }
2913                    }
2914                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2915                            _log.error(se, se);
2916    
2917                            throw se;
2918                    }
2919            }
2920    
2921            public static void unsubscribeFileEntryType(HttpPrincipal httpPrincipal,
2922                    long groupId, long fileEntryTypeId)
2923                    throws com.liferay.portal.kernel.exception.PortalException {
2924                    try {
2925                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2926                                            "unsubscribeFileEntryType",
2927                                            _unsubscribeFileEntryTypeParameterTypes88);
2928    
2929                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2930                                            fileEntryTypeId);
2931    
2932                            try {
2933                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2934                            }
2935                            catch (Exception e) {
2936                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2937                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2938                                    }
2939    
2940                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2941                            }
2942                    }
2943                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2944                            _log.error(se, se);
2945    
2946                            throw se;
2947                    }
2948            }
2949    
2950            public static void unsubscribeFolder(HttpPrincipal httpPrincipal,
2951                    long groupId, long folderId)
2952                    throws com.liferay.portal.kernel.exception.PortalException {
2953                    try {
2954                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2955                                            "unsubscribeFolder", _unsubscribeFolderParameterTypes89);
2956    
2957                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2958                                            folderId);
2959    
2960                            try {
2961                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2962                            }
2963                            catch (Exception e) {
2964                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2965                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2966                                    }
2967    
2968                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2969                            }
2970                    }
2971                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2972                            _log.error(se, se);
2973    
2974                            throw se;
2975                    }
2976            }
2977    
2978            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
2979                    HttpPrincipal httpPrincipal, long fileEntryId,
2980                    java.lang.String sourceFileName, java.lang.String mimeType,
2981                    java.lang.String title, java.lang.String description,
2982                    java.lang.String changeLog, boolean majorVersion, byte[] bytes,
2983                    com.liferay.portal.service.ServiceContext serviceContext)
2984                    throws com.liferay.portal.kernel.exception.PortalException {
2985                    try {
2986                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2987                                            "updateFileEntry", _updateFileEntryParameterTypes90);
2988    
2989                            MethodHandler methodHandler = new MethodHandler(methodKey,
2990                                            fileEntryId, sourceFileName, mimeType, title, description,
2991                                            changeLog, majorVersion, bytes, serviceContext);
2992    
2993                            Object returnObj = null;
2994    
2995                            try {
2996                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2997                            }
2998                            catch (Exception e) {
2999                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3000                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3001                                    }
3002    
3003                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3004                            }
3005    
3006                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3007                    }
3008                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3009                            _log.error(se, se);
3010    
3011                            throw se;
3012                    }
3013            }
3014    
3015            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
3016                    HttpPrincipal httpPrincipal, long fileEntryId,
3017                    java.lang.String sourceFileName, java.lang.String mimeType,
3018                    java.lang.String title, java.lang.String description,
3019                    java.lang.String changeLog, boolean majorVersion, java.io.File file,
3020                    com.liferay.portal.service.ServiceContext serviceContext)
3021                    throws com.liferay.portal.kernel.exception.PortalException {
3022                    try {
3023                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3024                                            "updateFileEntry", _updateFileEntryParameterTypes91);
3025    
3026                            MethodHandler methodHandler = new MethodHandler(methodKey,
3027                                            fileEntryId, sourceFileName, mimeType, title, description,
3028                                            changeLog, majorVersion, file, serviceContext);
3029    
3030                            Object returnObj = null;
3031    
3032                            try {
3033                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3034                            }
3035                            catch (Exception e) {
3036                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3037                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3038                                    }
3039    
3040                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3041                            }
3042    
3043                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3044                    }
3045                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3046                            _log.error(se, se);
3047    
3048                            throw se;
3049                    }
3050            }
3051    
3052            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
3053                    HttpPrincipal httpPrincipal, long fileEntryId,
3054                    java.lang.String sourceFileName, java.lang.String mimeType,
3055                    java.lang.String title, java.lang.String description,
3056                    java.lang.String changeLog, boolean majorVersion,
3057                    java.io.InputStream is, long size,
3058                    com.liferay.portal.service.ServiceContext serviceContext)
3059                    throws com.liferay.portal.kernel.exception.PortalException {
3060                    try {
3061                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3062                                            "updateFileEntry", _updateFileEntryParameterTypes92);
3063    
3064                            MethodHandler methodHandler = new MethodHandler(methodKey,
3065                                            fileEntryId, sourceFileName, mimeType, title, description,
3066                                            changeLog, majorVersion, is, size, serviceContext);
3067    
3068                            Object returnObj = null;
3069    
3070                            try {
3071                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3072                            }
3073                            catch (Exception e) {
3074                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3075                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3076                                    }
3077    
3078                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3079                            }
3080    
3081                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3082                    }
3083                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3084                            _log.error(se, se);
3085    
3086                            throw se;
3087                    }
3088            }
3089    
3090            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
3091                    HttpPrincipal httpPrincipal, long fileEntryId,
3092                    java.lang.String sourceFileName, java.lang.String mimeType,
3093                    java.lang.String title, java.lang.String description,
3094                    java.lang.String changeLog, boolean majorVersion, java.io.File file,
3095                    com.liferay.portal.service.ServiceContext serviceContext)
3096                    throws com.liferay.portal.kernel.exception.PortalException {
3097                    try {
3098                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3099                                            "updateFileEntryAndCheckIn",
3100                                            _updateFileEntryAndCheckInParameterTypes93);
3101    
3102                            MethodHandler methodHandler = new MethodHandler(methodKey,
3103                                            fileEntryId, sourceFileName, mimeType, title, description,
3104                                            changeLog, majorVersion, file, serviceContext);
3105    
3106                            Object returnObj = null;
3107    
3108                            try {
3109                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3110                            }
3111                            catch (Exception e) {
3112                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3113                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3114                                    }
3115    
3116                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3117                            }
3118    
3119                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3120                    }
3121                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3122                            _log.error(se, se);
3123    
3124                            throw se;
3125                    }
3126            }
3127    
3128            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
3129                    HttpPrincipal httpPrincipal, long fileEntryId,
3130                    java.lang.String sourceFileName, java.lang.String mimeType,
3131                    java.lang.String title, java.lang.String description,
3132                    java.lang.String changeLog, boolean majorVersion,
3133                    java.io.InputStream is, long size,
3134                    com.liferay.portal.service.ServiceContext serviceContext)
3135                    throws com.liferay.portal.kernel.exception.PortalException {
3136                    try {
3137                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3138                                            "updateFileEntryAndCheckIn",
3139                                            _updateFileEntryAndCheckInParameterTypes94);
3140    
3141                            MethodHandler methodHandler = new MethodHandler(methodKey,
3142                                            fileEntryId, sourceFileName, mimeType, title, description,
3143                                            changeLog, majorVersion, is, size, serviceContext);
3144    
3145                            Object returnObj = null;
3146    
3147                            try {
3148                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3149                            }
3150                            catch (Exception e) {
3151                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3152                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3153                                    }
3154    
3155                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3156                            }
3157    
3158                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3159                    }
3160                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3161                            _log.error(se, se);
3162    
3163                            throw se;
3164                    }
3165            }
3166    
3167            public static com.liferay.portal.kernel.repository.model.FileShortcut updateFileShortcut(
3168                    HttpPrincipal httpPrincipal, long fileShortcutId, long folderId,
3169                    long toFileEntryId,
3170                    com.liferay.portal.service.ServiceContext serviceContext)
3171                    throws com.liferay.portal.kernel.exception.PortalException {
3172                    try {
3173                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3174                                            "updateFileShortcut", _updateFileShortcutParameterTypes95);
3175    
3176                            MethodHandler methodHandler = new MethodHandler(methodKey,
3177                                            fileShortcutId, folderId, toFileEntryId, serviceContext);
3178    
3179                            Object returnObj = null;
3180    
3181                            try {
3182                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3183                            }
3184                            catch (Exception e) {
3185                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3186                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3187                                    }
3188    
3189                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3190                            }
3191    
3192                            return (com.liferay.portal.kernel.repository.model.FileShortcut)returnObj;
3193                    }
3194                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3195                            _log.error(se, se);
3196    
3197                            throw se;
3198                    }
3199            }
3200    
3201            public static com.liferay.portal.kernel.repository.model.Folder updateFolder(
3202                    HttpPrincipal httpPrincipal, long folderId, java.lang.String name,
3203                    java.lang.String description,
3204                    com.liferay.portal.service.ServiceContext serviceContext)
3205                    throws com.liferay.portal.kernel.exception.PortalException {
3206                    try {
3207                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3208                                            "updateFolder", _updateFolderParameterTypes96);
3209    
3210                            MethodHandler methodHandler = new MethodHandler(methodKey,
3211                                            folderId, name, description, serviceContext);
3212    
3213                            Object returnObj = null;
3214    
3215                            try {
3216                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3217                            }
3218                            catch (Exception e) {
3219                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3220                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3221                                    }
3222    
3223                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3224                            }
3225    
3226                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
3227                    }
3228                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3229                            _log.error(se, se);
3230    
3231                            throw se;
3232                    }
3233            }
3234    
3235            public static boolean verifyFileEntryCheckOut(HttpPrincipal httpPrincipal,
3236                    long repositoryId, long fileEntryId, java.lang.String lockUuid)
3237                    throws com.liferay.portal.kernel.exception.PortalException {
3238                    try {
3239                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3240                                            "verifyFileEntryCheckOut",
3241                                            _verifyFileEntryCheckOutParameterTypes97);
3242    
3243                            MethodHandler methodHandler = new MethodHandler(methodKey,
3244                                            repositoryId, fileEntryId, lockUuid);
3245    
3246                            Object returnObj = null;
3247    
3248                            try {
3249                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3250                            }
3251                            catch (Exception e) {
3252                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3253                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3254                                    }
3255    
3256                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3257                            }
3258    
3259                            return ((Boolean)returnObj).booleanValue();
3260                    }
3261                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3262                            _log.error(se, se);
3263    
3264                            throw se;
3265                    }
3266            }
3267    
3268            public static boolean verifyFileEntryLock(HttpPrincipal httpPrincipal,
3269                    long repositoryId, long fileEntryId, java.lang.String lockUuid)
3270                    throws com.liferay.portal.kernel.exception.PortalException {
3271                    try {
3272                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3273                                            "verifyFileEntryLock", _verifyFileEntryLockParameterTypes98);
3274    
3275                            MethodHandler methodHandler = new MethodHandler(methodKey,
3276                                            repositoryId, fileEntryId, lockUuid);
3277    
3278                            Object returnObj = null;
3279    
3280                            try {
3281                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3282                            }
3283                            catch (Exception e) {
3284                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3285                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3286                                    }
3287    
3288                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3289                            }
3290    
3291                            return ((Boolean)returnObj).booleanValue();
3292                    }
3293                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3294                            _log.error(se, se);
3295    
3296                            throw se;
3297                    }
3298            }
3299    
3300            public static boolean verifyInheritableLock(HttpPrincipal httpPrincipal,
3301                    long repositoryId, long folderId, java.lang.String lockUuid)
3302                    throws com.liferay.portal.kernel.exception.PortalException {
3303                    try {
3304                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3305                                            "verifyInheritableLock",
3306                                            _verifyInheritableLockParameterTypes99);
3307    
3308                            MethodHandler methodHandler = new MethodHandler(methodKey,
3309                                            repositoryId, folderId, lockUuid);
3310    
3311                            Object returnObj = null;
3312    
3313                            try {
3314                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3315                            }
3316                            catch (Exception e) {
3317                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3318                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3319                                    }
3320    
3321                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3322                            }
3323    
3324                            return ((Boolean)returnObj).booleanValue();
3325                    }
3326                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3327                            _log.error(se, se);
3328    
3329                            throw se;
3330                    }
3331            }
3332    
3333            private static Log _log = LogFactoryUtil.getLog(DLAppServiceHttp.class);
3334            private static final Class<?>[] _addFileEntryParameterTypes0 = new Class[] {
3335                            long.class, long.class, java.lang.String.class,
3336                            java.lang.String.class, java.lang.String.class,
3337                            java.lang.String.class, java.lang.String.class, byte[].class,
3338                            com.liferay.portal.service.ServiceContext.class
3339                    };
3340            private static final Class<?>[] _addFileEntryParameterTypes1 = new Class[] {
3341                            long.class, long.class, java.lang.String.class,
3342                            java.lang.String.class, java.lang.String.class,
3343                            java.lang.String.class, java.lang.String.class, java.io.File.class,
3344                            com.liferay.portal.service.ServiceContext.class
3345                    };
3346            private static final Class<?>[] _addFileEntryParameterTypes2 = new Class[] {
3347                            long.class, long.class, java.lang.String.class,
3348                            java.lang.String.class, java.lang.String.class,
3349                            java.lang.String.class, java.lang.String.class,
3350                            java.io.InputStream.class, long.class,
3351                            com.liferay.portal.service.ServiceContext.class
3352                    };
3353            private static final Class<?>[] _addFileShortcutParameterTypes3 = new Class[] {
3354                            long.class, long.class, long.class,
3355                            com.liferay.portal.service.ServiceContext.class
3356                    };
3357            private static final Class<?>[] _addFolderParameterTypes4 = new Class[] {
3358                            long.class, long.class, java.lang.String.class,
3359                            java.lang.String.class,
3360                            com.liferay.portal.service.ServiceContext.class
3361                    };
3362            private static final Class<?>[] _addTempFileEntryParameterTypes5 = new Class[] {
3363                            long.class, long.class, java.lang.String.class,
3364                            java.lang.String.class, java.io.File.class, java.lang.String.class
3365                    };
3366            private static final Class<?>[] _addTempFileEntryParameterTypes6 = new Class[] {
3367                            long.class, long.class, java.lang.String.class,
3368                            java.lang.String.class, java.io.InputStream.class,
3369                            java.lang.String.class
3370                    };
3371            private static final Class<?>[] _cancelCheckOutParameterTypes7 = new Class[] {
3372                            long.class
3373                    };
3374            private static final Class<?>[] _checkInFileEntryParameterTypes8 = new Class[] {
3375                            long.class, boolean.class, java.lang.String.class,
3376                            com.liferay.portal.service.ServiceContext.class
3377                    };
3378            private static final Class<?>[] _checkInFileEntryParameterTypes9 = new Class[] {
3379                            long.class, java.lang.String.class,
3380                            com.liferay.portal.service.ServiceContext.class
3381                    };
3382            private static final Class<?>[] _checkOutFileEntryParameterTypes10 = new Class[] {
3383                            long.class, com.liferay.portal.service.ServiceContext.class
3384                    };
3385            private static final Class<?>[] _checkOutFileEntryParameterTypes11 = new Class[] {
3386                            long.class, java.lang.String.class, long.class,
3387                            com.liferay.portal.service.ServiceContext.class
3388                    };
3389            private static final Class<?>[] _copyFolderParameterTypes12 = new Class[] {
3390                            long.class, long.class, long.class, java.lang.String.class,
3391                            java.lang.String.class,
3392                            com.liferay.portal.service.ServiceContext.class
3393                    };
3394            private static final Class<?>[] _deleteFileEntryParameterTypes13 = new Class[] {
3395                            long.class
3396                    };
3397            private static final Class<?>[] _deleteFileEntryByTitleParameterTypes14 = new Class[] {
3398                            long.class, long.class, java.lang.String.class
3399                    };
3400            private static final Class<?>[] _deleteFileShortcutParameterTypes15 = new Class[] {
3401                            long.class
3402                    };
3403            private static final Class<?>[] _deleteFileVersionParameterTypes16 = new Class[] {
3404                            long.class, java.lang.String.class
3405                    };
3406            private static final Class<?>[] _deleteFolderParameterTypes17 = new Class[] {
3407                            long.class
3408                    };
3409            private static final Class<?>[] _deleteFolderParameterTypes18 = new Class[] {
3410                            long.class, long.class, java.lang.String.class
3411                    };
3412            private static final Class<?>[] _deleteTempFileEntryParameterTypes19 = new Class[] {
3413                            long.class, long.class, java.lang.String.class,
3414                            java.lang.String.class
3415                    };
3416            private static final Class<?>[] _getFileEntriesParameterTypes20 = new Class[] {
3417                            long.class, long.class
3418                    };
3419            private static final Class<?>[] _getFileEntriesParameterTypes21 = new Class[] {
3420                            long.class, long.class, int.class, int.class
3421                    };
3422            private static final Class<?>[] _getFileEntriesParameterTypes22 = new Class[] {
3423                            long.class, long.class, int.class, int.class,
3424                            com.liferay.portal.kernel.util.OrderByComparator.class
3425                    };
3426            private static final Class<?>[] _getFileEntriesParameterTypes23 = new Class[] {
3427                            long.class, long.class, long.class
3428                    };
3429            private static final Class<?>[] _getFileEntriesParameterTypes24 = new Class[] {
3430                            long.class, long.class, long.class, int.class, int.class
3431                    };
3432            private static final Class<?>[] _getFileEntriesParameterTypes25 = new Class[] {
3433                            long.class, long.class, long.class, int.class, int.class,
3434                            com.liferay.portal.kernel.util.OrderByComparator.class
3435                    };
3436            private static final Class<?>[] _getFileEntriesParameterTypes26 = new Class[] {
3437                            long.class, long.class, java.lang.String[].class
3438                    };
3439            private static final Class<?>[] _getFileEntriesParameterTypes27 = new Class[] {
3440                            long.class, long.class, java.lang.String[].class, int.class,
3441                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
3442                    };
3443            private static final Class<?>[] _getFileEntriesAndFileShortcutsParameterTypes28 =
3444                    new Class[] { long.class, long.class, int.class, int.class, int.class };
3445            private static final Class<?>[] _getFileEntriesAndFileShortcutsCountParameterTypes29 =
3446                    new Class[] { long.class, long.class, int.class };
3447            private static final Class<?>[] _getFileEntriesAndFileShortcutsCountParameterTypes30 =
3448                    new Class[] { long.class, long.class, int.class, java.lang.String[].class };
3449            private static final Class<?>[] _getFileEntriesCountParameterTypes31 = new Class[] {
3450                            long.class, long.class
3451                    };
3452            private static final Class<?>[] _getFileEntriesCountParameterTypes32 = new Class[] {
3453                            long.class, long.class, long.class
3454                    };
3455            private static final Class<?>[] _getFileEntriesCountParameterTypes33 = new Class[] {
3456                            long.class, long.class, java.lang.String[].class
3457                    };
3458            private static final Class<?>[] _getFileEntryParameterTypes34 = new Class[] {
3459                            long.class
3460                    };
3461            private static final Class<?>[] _getFileEntryParameterTypes35 = new Class[] {
3462                            long.class, long.class, java.lang.String.class
3463                    };
3464            private static final Class<?>[] _getFileEntryByUuidAndGroupIdParameterTypes36 =
3465                    new Class[] { java.lang.String.class, long.class };
3466            private static final Class<?>[] _getFileShortcutParameterTypes37 = new Class[] {
3467                            long.class
3468                    };
3469            private static final Class<?>[] _getFileVersionParameterTypes38 = new Class[] {
3470                            long.class
3471                    };
3472            private static final Class<?>[] _getFolderParameterTypes39 = new Class[] {
3473                            long.class
3474                    };
3475            private static final Class<?>[] _getFolderParameterTypes40 = new Class[] {
3476                            long.class, long.class, java.lang.String.class
3477                    };
3478            private static final Class<?>[] _getFoldersParameterTypes41 = new Class[] {
3479                            long.class, long.class
3480                    };
3481            private static final Class<?>[] _getFoldersParameterTypes42 = new Class[] {
3482                            long.class, long.class, boolean.class
3483                    };
3484            private static final Class<?>[] _getFoldersParameterTypes43 = new Class[] {
3485                            long.class, long.class, boolean.class, int.class, int.class
3486                    };
3487            private static final Class<?>[] _getFoldersParameterTypes44 = new Class[] {
3488                            long.class, long.class, boolean.class, int.class, int.class,
3489                            com.liferay.portal.kernel.util.OrderByComparator.class
3490                    };
3491            private static final Class<?>[] _getFoldersParameterTypes45 = new Class[] {
3492                            long.class, long.class, int.class, boolean.class, int.class,
3493                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
3494                    };
3495            private static final Class<?>[] _getFoldersParameterTypes46 = new Class[] {
3496                            long.class, long.class, int.class, int.class
3497                    };
3498            private static final Class<?>[] _getFoldersParameterTypes47 = new Class[] {
3499                            long.class, long.class, int.class, int.class,
3500                            com.liferay.portal.kernel.util.OrderByComparator.class
3501                    };
3502            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsParameterTypes48 =
3503                    new Class[] {
3504                            long.class, long.class, int.class, boolean.class, int.class,
3505                            int.class
3506                    };
3507            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsParameterTypes49 =
3508                    new Class[] {
3509                            long.class, long.class, int.class, boolean.class, int.class,
3510                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
3511                    };
3512            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsParameterTypes50 =
3513                    new Class[] {
3514                            long.class, long.class, int.class, java.lang.String[].class,
3515                            boolean.class, int.class, int.class,
3516                            com.liferay.portal.kernel.util.OrderByComparator.class
3517                    };
3518            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsCountParameterTypes51 =
3519                    new Class[] { long.class, long.class, int.class, boolean.class };
3520            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsCountParameterTypes52 =
3521                    new Class[] {
3522                            long.class, long.class, int.class, java.lang.String[].class,
3523                            boolean.class
3524                    };
3525            private static final Class<?>[] _getFoldersCountParameterTypes53 = new Class[] {
3526                            long.class, long.class
3527                    };
3528            private static final Class<?>[] _getFoldersCountParameterTypes54 = new Class[] {
3529                            long.class, long.class, boolean.class
3530                    };
3531            private static final Class<?>[] _getFoldersCountParameterTypes55 = new Class[] {
3532                            long.class, long.class, int.class, boolean.class
3533                    };
3534            private static final Class<?>[] _getFoldersFileEntriesCountParameterTypes56 = new Class[] {
3535                            long.class, java.util.List.class, int.class
3536                    };
3537            private static final Class<?>[] _getGroupFileEntriesParameterTypes57 = new Class[] {
3538                            long.class, long.class, int.class, int.class
3539                    };
3540            private static final Class<?>[] _getGroupFileEntriesParameterTypes58 = new Class[] {
3541                            long.class, long.class, int.class, int.class,
3542                            com.liferay.portal.kernel.util.OrderByComparator.class
3543                    };
3544            private static final Class<?>[] _getGroupFileEntriesParameterTypes59 = new Class[] {
3545                            long.class, long.class, long.class, int.class, int.class
3546                    };
3547            private static final Class<?>[] _getGroupFileEntriesParameterTypes60 = new Class[] {
3548                            long.class, long.class, long.class, int.class, int.class,
3549                            com.liferay.portal.kernel.util.OrderByComparator.class
3550                    };
3551            private static final Class<?>[] _getGroupFileEntriesParameterTypes61 = new Class[] {
3552                            long.class, long.class, long.class, java.lang.String[].class,
3553                            int.class, int.class, int.class,
3554                            com.liferay.portal.kernel.util.OrderByComparator.class
3555                    };
3556            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes62 = new Class[] {
3557                            long.class, long.class
3558                    };
3559            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes63 = new Class[] {
3560                            long.class, long.class, long.class
3561                    };
3562            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes64 = new Class[] {
3563                            long.class, long.class, long.class, java.lang.String[].class,
3564                            int.class
3565                    };
3566            private static final Class<?>[] _getMountFoldersParameterTypes65 = new Class[] {
3567                            long.class, long.class
3568                    };
3569            private static final Class<?>[] _getMountFoldersParameterTypes66 = new Class[] {
3570                            long.class, long.class, int.class, int.class
3571                    };
3572            private static final Class<?>[] _getMountFoldersParameterTypes67 = new Class[] {
3573                            long.class, long.class, int.class, int.class,
3574                            com.liferay.portal.kernel.util.OrderByComparator.class
3575                    };
3576            private static final Class<?>[] _getMountFoldersCountParameterTypes68 = new Class[] {
3577                            long.class, long.class
3578                    };
3579            private static final Class<?>[] _getSubfolderIdsParameterTypes69 = new Class[] {
3580                            long.class, java.util.List.class, long.class
3581                    };
3582            private static final Class<?>[] _getSubfolderIdsParameterTypes70 = new Class[] {
3583                            long.class, long.class
3584                    };
3585            private static final Class<?>[] _getSubfolderIdsParameterTypes71 = new Class[] {
3586                            long.class, long.class, boolean.class
3587                    };
3588            private static final Class<?>[] _getTempFileNamesParameterTypes72 = new Class[] {
3589                            long.class, long.class, java.lang.String.class
3590                    };
3591            private static final Class<?>[] _lockFolderParameterTypes73 = new Class[] {
3592                            long.class, long.class
3593                    };
3594            private static final Class<?>[] _lockFolderParameterTypes74 = new Class[] {
3595                            long.class, long.class, java.lang.String.class, boolean.class,
3596                            long.class
3597                    };
3598            private static final Class<?>[] _moveFileEntryParameterTypes75 = new Class[] {
3599                            long.class, long.class,
3600                            com.liferay.portal.service.ServiceContext.class
3601                    };
3602            private static final Class<?>[] _moveFolderParameterTypes76 = new Class[] {
3603                            long.class, long.class,
3604                            com.liferay.portal.service.ServiceContext.class
3605                    };
3606            private static final Class<?>[] _refreshFileEntryLockParameterTypes77 = new Class[] {
3607                            java.lang.String.class, long.class, long.class
3608                    };
3609            private static final Class<?>[] _refreshFolderLockParameterTypes78 = new Class[] {
3610                            java.lang.String.class, long.class, long.class
3611                    };
3612            private static final Class<?>[] _revertFileEntryParameterTypes79 = new Class[] {
3613                            long.class, java.lang.String.class,
3614                            com.liferay.portal.service.ServiceContext.class
3615                    };
3616            private static final Class<?>[] _searchParameterTypes80 = new Class[] {
3617                            long.class, long.class, int.class, int.class, int.class
3618                    };
3619            private static final Class<?>[] _searchParameterTypes81 = new Class[] {
3620                            long.class, long.class, long.class, java.lang.String[].class,
3621                            int.class, int.class, int.class
3622                    };
3623            private static final Class<?>[] _searchParameterTypes82 = new Class[] {
3624                            long.class, com.liferay.portal.kernel.search.SearchContext.class
3625                    };
3626            private static final Class<?>[] _searchParameterTypes83 = new Class[] {
3627                            long.class, com.liferay.portal.kernel.search.SearchContext.class,
3628                            com.liferay.portal.kernel.search.Query.class
3629                    };
3630            private static final Class<?>[] _subscribeFileEntryTypeParameterTypes84 = new Class[] {
3631                            long.class, long.class
3632                    };
3633            private static final Class<?>[] _subscribeFolderParameterTypes85 = new Class[] {
3634                            long.class, long.class
3635                    };
3636            private static final Class<?>[] _unlockFolderParameterTypes86 = new Class[] {
3637                            long.class, long.class, java.lang.String.class
3638                    };
3639            private static final Class<?>[] _unlockFolderParameterTypes87 = new Class[] {
3640                            long.class, long.class, java.lang.String.class,
3641                            java.lang.String.class
3642                    };
3643            private static final Class<?>[] _unsubscribeFileEntryTypeParameterTypes88 = new Class[] {
3644                            long.class, long.class
3645                    };
3646            private static final Class<?>[] _unsubscribeFolderParameterTypes89 = new Class[] {
3647                            long.class, long.class
3648                    };
3649            private static final Class<?>[] _updateFileEntryParameterTypes90 = new Class[] {
3650                            long.class, java.lang.String.class, java.lang.String.class,
3651                            java.lang.String.class, java.lang.String.class,
3652                            java.lang.String.class, boolean.class, byte[].class,
3653                            com.liferay.portal.service.ServiceContext.class
3654                    };
3655            private static final Class<?>[] _updateFileEntryParameterTypes91 = new Class[] {
3656                            long.class, java.lang.String.class, java.lang.String.class,
3657                            java.lang.String.class, java.lang.String.class,
3658                            java.lang.String.class, boolean.class, java.io.File.class,
3659                            com.liferay.portal.service.ServiceContext.class
3660                    };
3661            private static final Class<?>[] _updateFileEntryParameterTypes92 = new Class[] {
3662                            long.class, java.lang.String.class, java.lang.String.class,
3663                            java.lang.String.class, java.lang.String.class,
3664                            java.lang.String.class, boolean.class, java.io.InputStream.class,
3665                            long.class, com.liferay.portal.service.ServiceContext.class
3666                    };
3667            private static final Class<?>[] _updateFileEntryAndCheckInParameterTypes93 = new Class[] {
3668                            long.class, java.lang.String.class, java.lang.String.class,
3669                            java.lang.String.class, java.lang.String.class,
3670                            java.lang.String.class, boolean.class, java.io.File.class,
3671                            com.liferay.portal.service.ServiceContext.class
3672                    };
3673            private static final Class<?>[] _updateFileEntryAndCheckInParameterTypes94 = new Class[] {
3674                            long.class, java.lang.String.class, java.lang.String.class,
3675                            java.lang.String.class, java.lang.String.class,
3676                            java.lang.String.class, boolean.class, java.io.InputStream.class,
3677                            long.class, com.liferay.portal.service.ServiceContext.class
3678                    };
3679            private static final Class<?>[] _updateFileShortcutParameterTypes95 = new Class[] {
3680                            long.class, long.class, long.class,
3681                            com.liferay.portal.service.ServiceContext.class
3682                    };
3683            private static final Class<?>[] _updateFolderParameterTypes96 = new Class[] {
3684                            long.class, java.lang.String.class, java.lang.String.class,
3685                            com.liferay.portal.service.ServiceContext.class
3686                    };
3687            private static final Class<?>[] _verifyFileEntryCheckOutParameterTypes97 = new Class[] {
3688                            long.class, long.class, java.lang.String.class
3689                    };
3690            private static final Class<?>[] _verifyFileEntryLockParameterTypes98 = new Class[] {
3691                            long.class, long.class, java.lang.String.class
3692                    };
3693            private static final Class<?>[] _verifyInheritableLockParameterTypes99 = new Class[] {
3694                            long.class, long.class, java.lang.String.class
3695                    };
3696    }