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