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 com.liferay.portlet.documentlibrary.service.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 com.liferay.portal.security.auth.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 com.liferay.portal.security.auth.HttpPrincipal
053     * @see com.liferay.portlet.documentlibrary.service.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.portlet.documentlibrary.model.DLFileShortcut 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.portlet.documentlibrary.model.DLFileShortcut)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.portlet.documentlibrary.model.DLFileShortcut 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.portlet.documentlibrary.model.DLFileShortcut)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.model.Lock lockFileEntry(
2475                    HttpPrincipal httpPrincipal, long fileEntryId)
2476                    throws com.liferay.portal.kernel.exception.PortalException {
2477                    try {
2478                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2479                                            "lockFileEntry", _lockFileEntryParameterTypes74);
2480    
2481                            MethodHandler methodHandler = new MethodHandler(methodKey,
2482                                            fileEntryId);
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.model.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.model.Lock lockFileEntry(
2507                    HttpPrincipal httpPrincipal, long fileEntryId, java.lang.String owner,
2508                    long expirationTime)
2509                    throws com.liferay.portal.kernel.exception.PortalException {
2510                    try {
2511                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2512                                            "lockFileEntry", _lockFileEntryParameterTypes75);
2513    
2514                            MethodHandler methodHandler = new MethodHandler(methodKey,
2515                                            fileEntryId, owner, 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.model.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.model.Lock lockFolder(
2540                    HttpPrincipal httpPrincipal, long repositoryId, long folderId)
2541                    throws com.liferay.portal.kernel.exception.PortalException {
2542                    try {
2543                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2544                                            "lockFolder", _lockFolderParameterTypes76);
2545    
2546                            MethodHandler methodHandler = new MethodHandler(methodKey,
2547                                            repositoryId, folderId);
2548    
2549                            Object returnObj = null;
2550    
2551                            try {
2552                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2553                            }
2554                            catch (Exception e) {
2555                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2556                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2557                                    }
2558    
2559                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2560                            }
2561    
2562                            return (com.liferay.portal.model.Lock)returnObj;
2563                    }
2564                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2565                            _log.error(se, se);
2566    
2567                            throw se;
2568                    }
2569            }
2570    
2571            public static com.liferay.portal.model.Lock lockFolder(
2572                    HttpPrincipal httpPrincipal, long repositoryId, long folderId,
2573                    java.lang.String owner, boolean inheritable, long expirationTime)
2574                    throws com.liferay.portal.kernel.exception.PortalException {
2575                    try {
2576                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2577                                            "lockFolder", _lockFolderParameterTypes77);
2578    
2579                            MethodHandler methodHandler = new MethodHandler(methodKey,
2580                                            repositoryId, folderId, owner, inheritable, expirationTime);
2581    
2582                            Object returnObj = null;
2583    
2584                            try {
2585                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2586                            }
2587                            catch (Exception e) {
2588                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2589                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2590                                    }
2591    
2592                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2593                            }
2594    
2595                            return (com.liferay.portal.model.Lock)returnObj;
2596                    }
2597                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2598                            _log.error(se, se);
2599    
2600                            throw se;
2601                    }
2602            }
2603    
2604            public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntry(
2605                    HttpPrincipal httpPrincipal, long fileEntryId, long newFolderId,
2606                    com.liferay.portal.service.ServiceContext serviceContext)
2607                    throws com.liferay.portal.kernel.exception.PortalException {
2608                    try {
2609                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2610                                            "moveFileEntry", _moveFileEntryParameterTypes78);
2611    
2612                            MethodHandler methodHandler = new MethodHandler(methodKey,
2613                                            fileEntryId, newFolderId, serviceContext);
2614    
2615                            Object returnObj = null;
2616    
2617                            try {
2618                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2619                            }
2620                            catch (Exception e) {
2621                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2622                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2623                                    }
2624    
2625                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2626                            }
2627    
2628                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
2629                    }
2630                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2631                            _log.error(se, se);
2632    
2633                            throw se;
2634                    }
2635            }
2636    
2637            public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryFromTrash(
2638                    HttpPrincipal httpPrincipal, long fileEntryId, long newFolderId,
2639                    com.liferay.portal.service.ServiceContext serviceContext)
2640                    throws com.liferay.portal.kernel.exception.PortalException {
2641                    try {
2642                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2643                                            "moveFileEntryFromTrash",
2644                                            _moveFileEntryFromTrashParameterTypes79);
2645    
2646                            MethodHandler methodHandler = new MethodHandler(methodKey,
2647                                            fileEntryId, newFolderId, serviceContext);
2648    
2649                            Object returnObj = null;
2650    
2651                            try {
2652                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2653                            }
2654                            catch (Exception e) {
2655                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2656                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2657                                    }
2658    
2659                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2660                            }
2661    
2662                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
2663                    }
2664                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2665                            _log.error(se, se);
2666    
2667                            throw se;
2668                    }
2669            }
2670    
2671            public static com.liferay.portal.kernel.repository.model.FileEntry moveFileEntryToTrash(
2672                    HttpPrincipal httpPrincipal, long fileEntryId)
2673                    throws com.liferay.portal.kernel.exception.PortalException {
2674                    try {
2675                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2676                                            "moveFileEntryToTrash",
2677                                            _moveFileEntryToTrashParameterTypes80);
2678    
2679                            MethodHandler methodHandler = new MethodHandler(methodKey,
2680                                            fileEntryId);
2681    
2682                            Object returnObj = null;
2683    
2684                            try {
2685                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2686                            }
2687                            catch (Exception e) {
2688                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2689                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2690                                    }
2691    
2692                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2693                            }
2694    
2695                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
2696                    }
2697                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2698                            _log.error(se, se);
2699    
2700                            throw se;
2701                    }
2702            }
2703    
2704            public static com.liferay.portlet.documentlibrary.model.DLFileShortcut moveFileShortcutFromTrash(
2705                    HttpPrincipal httpPrincipal, long fileShortcutId, long newFolderId,
2706                    com.liferay.portal.service.ServiceContext serviceContext)
2707                    throws com.liferay.portal.kernel.exception.PortalException {
2708                    try {
2709                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2710                                            "moveFileShortcutFromTrash",
2711                                            _moveFileShortcutFromTrashParameterTypes81);
2712    
2713                            MethodHandler methodHandler = new MethodHandler(methodKey,
2714                                            fileShortcutId, newFolderId, serviceContext);
2715    
2716                            Object returnObj = null;
2717    
2718                            try {
2719                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2720                            }
2721                            catch (Exception e) {
2722                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2723                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2724                                    }
2725    
2726                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2727                            }
2728    
2729                            return (com.liferay.portlet.documentlibrary.model.DLFileShortcut)returnObj;
2730                    }
2731                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2732                            _log.error(se, se);
2733    
2734                            throw se;
2735                    }
2736            }
2737    
2738            public static com.liferay.portlet.documentlibrary.model.DLFileShortcut moveFileShortcutToTrash(
2739                    HttpPrincipal httpPrincipal, long fileShortcutId)
2740                    throws com.liferay.portal.kernel.exception.PortalException {
2741                    try {
2742                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2743                                            "moveFileShortcutToTrash",
2744                                            _moveFileShortcutToTrashParameterTypes82);
2745    
2746                            MethodHandler methodHandler = new MethodHandler(methodKey,
2747                                            fileShortcutId);
2748    
2749                            Object returnObj = null;
2750    
2751                            try {
2752                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2753                            }
2754                            catch (Exception e) {
2755                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2756                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2757                                    }
2758    
2759                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2760                            }
2761    
2762                            return (com.liferay.portlet.documentlibrary.model.DLFileShortcut)returnObj;
2763                    }
2764                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2765                            _log.error(se, se);
2766    
2767                            throw se;
2768                    }
2769            }
2770    
2771            public static com.liferay.portal.kernel.repository.model.Folder moveFolder(
2772                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
2773                    com.liferay.portal.service.ServiceContext serviceContext)
2774                    throws com.liferay.portal.kernel.exception.PortalException {
2775                    try {
2776                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2777                                            "moveFolder", _moveFolderParameterTypes83);
2778    
2779                            MethodHandler methodHandler = new MethodHandler(methodKey,
2780                                            folderId, parentFolderId, serviceContext);
2781    
2782                            Object returnObj = null;
2783    
2784                            try {
2785                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2786                            }
2787                            catch (Exception e) {
2788                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2789                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2790                                    }
2791    
2792                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2793                            }
2794    
2795                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
2796                    }
2797                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2798                            _log.error(se, se);
2799    
2800                            throw se;
2801                    }
2802            }
2803    
2804            public static com.liferay.portal.kernel.repository.model.Folder moveFolderFromTrash(
2805                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
2806                    com.liferay.portal.service.ServiceContext serviceContext)
2807                    throws com.liferay.portal.kernel.exception.PortalException {
2808                    try {
2809                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2810                                            "moveFolderFromTrash", _moveFolderFromTrashParameterTypes84);
2811    
2812                            MethodHandler methodHandler = new MethodHandler(methodKey,
2813                                            folderId, parentFolderId, serviceContext);
2814    
2815                            Object returnObj = null;
2816    
2817                            try {
2818                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2819                            }
2820                            catch (Exception e) {
2821                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2822                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2823                                    }
2824    
2825                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2826                            }
2827    
2828                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
2829                    }
2830                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2831                            _log.error(se, se);
2832    
2833                            throw se;
2834                    }
2835            }
2836    
2837            public static com.liferay.portal.kernel.repository.model.Folder moveFolderToTrash(
2838                    HttpPrincipal httpPrincipal, long folderId)
2839                    throws com.liferay.portal.kernel.exception.PortalException {
2840                    try {
2841                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2842                                            "moveFolderToTrash", _moveFolderToTrashParameterTypes85);
2843    
2844                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
2845    
2846                            Object returnObj = null;
2847    
2848                            try {
2849                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2850                            }
2851                            catch (Exception e) {
2852                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2853                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2854                                    }
2855    
2856                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2857                            }
2858    
2859                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
2860                    }
2861                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2862                            _log.error(se, se);
2863    
2864                            throw se;
2865                    }
2866            }
2867    
2868            public static com.liferay.portal.model.Lock refreshFileEntryLock(
2869                    HttpPrincipal httpPrincipal, java.lang.String lockUuid, long companyId,
2870                    long expirationTime)
2871                    throws com.liferay.portal.kernel.exception.PortalException {
2872                    try {
2873                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2874                                            "refreshFileEntryLock",
2875                                            _refreshFileEntryLockParameterTypes86);
2876    
2877                            MethodHandler methodHandler = new MethodHandler(methodKey,
2878                                            lockUuid, companyId, expirationTime);
2879    
2880                            Object returnObj = null;
2881    
2882                            try {
2883                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2884                            }
2885                            catch (Exception e) {
2886                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2887                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2888                                    }
2889    
2890                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2891                            }
2892    
2893                            return (com.liferay.portal.model.Lock)returnObj;
2894                    }
2895                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2896                            _log.error(se, se);
2897    
2898                            throw se;
2899                    }
2900            }
2901    
2902            public static com.liferay.portal.model.Lock refreshFolderLock(
2903                    HttpPrincipal httpPrincipal, java.lang.String lockUuid, long companyId,
2904                    long expirationTime)
2905                    throws com.liferay.portal.kernel.exception.PortalException {
2906                    try {
2907                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2908                                            "refreshFolderLock", _refreshFolderLockParameterTypes87);
2909    
2910                            MethodHandler methodHandler = new MethodHandler(methodKey,
2911                                            lockUuid, companyId, expirationTime);
2912    
2913                            Object returnObj = null;
2914    
2915                            try {
2916                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2917                            }
2918                            catch (Exception e) {
2919                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2920                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2921                                    }
2922    
2923                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2924                            }
2925    
2926                            return (com.liferay.portal.model.Lock)returnObj;
2927                    }
2928                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2929                            _log.error(se, se);
2930    
2931                            throw se;
2932                    }
2933            }
2934    
2935            public static void restoreFileEntryFromTrash(HttpPrincipal httpPrincipal,
2936                    long fileEntryId)
2937                    throws com.liferay.portal.kernel.exception.PortalException {
2938                    try {
2939                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2940                                            "restoreFileEntryFromTrash",
2941                                            _restoreFileEntryFromTrashParameterTypes88);
2942    
2943                            MethodHandler methodHandler = new MethodHandler(methodKey,
2944                                            fileEntryId);
2945    
2946                            try {
2947                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2948                            }
2949                            catch (Exception e) {
2950                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2951                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2952                                    }
2953    
2954                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2955                            }
2956                    }
2957                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2958                            _log.error(se, se);
2959    
2960                            throw se;
2961                    }
2962            }
2963    
2964            public static void restoreFileShortcutFromTrash(
2965                    HttpPrincipal httpPrincipal, long fileShortcutId)
2966                    throws com.liferay.portal.kernel.exception.PortalException {
2967                    try {
2968                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2969                                            "restoreFileShortcutFromTrash",
2970                                            _restoreFileShortcutFromTrashParameterTypes89);
2971    
2972                            MethodHandler methodHandler = new MethodHandler(methodKey,
2973                                            fileShortcutId);
2974    
2975                            try {
2976                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
2977                            }
2978                            catch (Exception e) {
2979                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2980                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2981                                    }
2982    
2983                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2984                            }
2985                    }
2986                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2987                            _log.error(se, se);
2988    
2989                            throw se;
2990                    }
2991            }
2992    
2993            public static void restoreFolderFromTrash(HttpPrincipal httpPrincipal,
2994                    long folderId)
2995                    throws com.liferay.portal.kernel.exception.PortalException {
2996                    try {
2997                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
2998                                            "restoreFolderFromTrash",
2999                                            _restoreFolderFromTrashParameterTypes90);
3000    
3001                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
3002    
3003                            try {
3004                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3005                            }
3006                            catch (Exception e) {
3007                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3008                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3009                                    }
3010    
3011                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3012                            }
3013                    }
3014                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3015                            _log.error(se, se);
3016    
3017                            throw se;
3018                    }
3019            }
3020    
3021            public static void revertFileEntry(HttpPrincipal httpPrincipal,
3022                    long fileEntryId, java.lang.String version,
3023                    com.liferay.portal.service.ServiceContext serviceContext)
3024                    throws com.liferay.portal.kernel.exception.PortalException {
3025                    try {
3026                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3027                                            "revertFileEntry", _revertFileEntryParameterTypes91);
3028    
3029                            MethodHandler methodHandler = new MethodHandler(methodKey,
3030                                            fileEntryId, version, serviceContext);
3031    
3032                            try {
3033                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3034                            }
3035                            catch (Exception e) {
3036                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3037                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3038                                    }
3039    
3040                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3041                            }
3042                    }
3043                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3044                            _log.error(se, se);
3045    
3046                            throw se;
3047                    }
3048            }
3049    
3050            public static com.liferay.portal.kernel.search.Hits search(
3051                    HttpPrincipal httpPrincipal, long repositoryId, long creatorUserId,
3052                    int status, int start, int end)
3053                    throws com.liferay.portal.kernel.exception.PortalException {
3054                    try {
3055                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3056                                            "search", _searchParameterTypes92);
3057    
3058                            MethodHandler methodHandler = new MethodHandler(methodKey,
3059                                            repositoryId, creatorUserId, status, start, end);
3060    
3061                            Object returnObj = null;
3062    
3063                            try {
3064                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3065                            }
3066                            catch (Exception e) {
3067                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3068                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3069                                    }
3070    
3071                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3072                            }
3073    
3074                            return (com.liferay.portal.kernel.search.Hits)returnObj;
3075                    }
3076                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3077                            _log.error(se, se);
3078    
3079                            throw se;
3080                    }
3081            }
3082    
3083            public static com.liferay.portal.kernel.search.Hits search(
3084                    HttpPrincipal httpPrincipal, long repositoryId, long creatorUserId,
3085                    long folderId, java.lang.String[] mimeTypes, int status, int start,
3086                    int end) throws com.liferay.portal.kernel.exception.PortalException {
3087                    try {
3088                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3089                                            "search", _searchParameterTypes93);
3090    
3091                            MethodHandler methodHandler = new MethodHandler(methodKey,
3092                                            repositoryId, creatorUserId, folderId, mimeTypes, status,
3093                                            start, end);
3094    
3095                            Object returnObj = null;
3096    
3097                            try {
3098                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3099                            }
3100                            catch (Exception e) {
3101                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3102                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3103                                    }
3104    
3105                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3106                            }
3107    
3108                            return (com.liferay.portal.kernel.search.Hits)returnObj;
3109                    }
3110                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3111                            _log.error(se, se);
3112    
3113                            throw se;
3114                    }
3115            }
3116    
3117            public static com.liferay.portal.kernel.search.Hits search(
3118                    HttpPrincipal httpPrincipal, long repositoryId,
3119                    com.liferay.portal.kernel.search.SearchContext searchContext)
3120                    throws com.liferay.portal.kernel.search.SearchException {
3121                    try {
3122                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3123                                            "search", _searchParameterTypes94);
3124    
3125                            MethodHandler methodHandler = new MethodHandler(methodKey,
3126                                            repositoryId, searchContext);
3127    
3128                            Object returnObj = null;
3129    
3130                            try {
3131                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3132                            }
3133                            catch (Exception e) {
3134                                    if (e instanceof com.liferay.portal.kernel.search.SearchException) {
3135                                            throw (com.liferay.portal.kernel.search.SearchException)e;
3136                                    }
3137    
3138                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3139                            }
3140    
3141                            return (com.liferay.portal.kernel.search.Hits)returnObj;
3142                    }
3143                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3144                            _log.error(se, se);
3145    
3146                            throw se;
3147                    }
3148            }
3149    
3150            public static com.liferay.portal.kernel.search.Hits search(
3151                    HttpPrincipal httpPrincipal, long repositoryId,
3152                    com.liferay.portal.kernel.search.SearchContext searchContext,
3153                    com.liferay.portal.kernel.search.Query query)
3154                    throws com.liferay.portal.kernel.search.SearchException {
3155                    try {
3156                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3157                                            "search", _searchParameterTypes95);
3158    
3159                            MethodHandler methodHandler = new MethodHandler(methodKey,
3160                                            repositoryId, searchContext, query);
3161    
3162                            Object returnObj = null;
3163    
3164                            try {
3165                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3166                            }
3167                            catch (Exception e) {
3168                                    if (e instanceof com.liferay.portal.kernel.search.SearchException) {
3169                                            throw (com.liferay.portal.kernel.search.SearchException)e;
3170                                    }
3171    
3172                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3173                            }
3174    
3175                            return (com.liferay.portal.kernel.search.Hits)returnObj;
3176                    }
3177                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3178                            _log.error(se, se);
3179    
3180                            throw se;
3181                    }
3182            }
3183    
3184            public static void subscribeFileEntryType(HttpPrincipal httpPrincipal,
3185                    long groupId, long fileEntryTypeId)
3186                    throws com.liferay.portal.kernel.exception.PortalException {
3187                    try {
3188                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3189                                            "subscribeFileEntryType",
3190                                            _subscribeFileEntryTypeParameterTypes96);
3191    
3192                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
3193                                            fileEntryTypeId);
3194    
3195                            try {
3196                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3197                            }
3198                            catch (Exception e) {
3199                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3200                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3201                                    }
3202    
3203                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3204                            }
3205                    }
3206                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3207                            _log.error(se, se);
3208    
3209                            throw se;
3210                    }
3211            }
3212    
3213            public static void subscribeFolder(HttpPrincipal httpPrincipal,
3214                    long groupId, long folderId)
3215                    throws com.liferay.portal.kernel.exception.PortalException {
3216                    try {
3217                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3218                                            "subscribeFolder", _subscribeFolderParameterTypes97);
3219    
3220                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
3221                                            folderId);
3222    
3223                            try {
3224                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3225                            }
3226                            catch (Exception e) {
3227                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3228                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3229                                    }
3230    
3231                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3232                            }
3233                    }
3234                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3235                            _log.error(se, se);
3236    
3237                            throw se;
3238                    }
3239            }
3240    
3241            public static void unlockFileEntry(HttpPrincipal httpPrincipal,
3242                    long fileEntryId)
3243                    throws com.liferay.portal.kernel.exception.PortalException {
3244                    try {
3245                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3246                                            "unlockFileEntry", _unlockFileEntryParameterTypes98);
3247    
3248                            MethodHandler methodHandler = new MethodHandler(methodKey,
3249                                            fileEntryId);
3250    
3251                            try {
3252                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3253                            }
3254                            catch (Exception e) {
3255                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3256                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3257                                    }
3258    
3259                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3260                            }
3261                    }
3262                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3263                            _log.error(se, se);
3264    
3265                            throw se;
3266                    }
3267            }
3268    
3269            public static void unlockFileEntry(HttpPrincipal httpPrincipal,
3270                    long fileEntryId, java.lang.String lockUuid)
3271                    throws com.liferay.portal.kernel.exception.PortalException {
3272                    try {
3273                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3274                                            "unlockFileEntry", _unlockFileEntryParameterTypes99);
3275    
3276                            MethodHandler methodHandler = new MethodHandler(methodKey,
3277                                            fileEntryId, lockUuid);
3278    
3279                            try {
3280                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3281                            }
3282                            catch (Exception e) {
3283                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3284                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3285                                    }
3286    
3287                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3288                            }
3289                    }
3290                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3291                            _log.error(se, se);
3292    
3293                            throw se;
3294                    }
3295            }
3296    
3297            public static void unlockFolder(HttpPrincipal httpPrincipal,
3298                    long repositoryId, long folderId, java.lang.String lockUuid)
3299                    throws com.liferay.portal.kernel.exception.PortalException {
3300                    try {
3301                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3302                                            "unlockFolder", _unlockFolderParameterTypes100);
3303    
3304                            MethodHandler methodHandler = new MethodHandler(methodKey,
3305                                            repositoryId, folderId, lockUuid);
3306    
3307                            try {
3308                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3309                            }
3310                            catch (Exception e) {
3311                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3312                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3313                                    }
3314    
3315                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3316                            }
3317                    }
3318                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3319                            _log.error(se, se);
3320    
3321                            throw se;
3322                    }
3323            }
3324    
3325            public static void unlockFolder(HttpPrincipal httpPrincipal,
3326                    long repositoryId, long parentFolderId, java.lang.String name,
3327                    java.lang.String lockUuid)
3328                    throws com.liferay.portal.kernel.exception.PortalException {
3329                    try {
3330                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3331                                            "unlockFolder", _unlockFolderParameterTypes101);
3332    
3333                            MethodHandler methodHandler = new MethodHandler(methodKey,
3334                                            repositoryId, parentFolderId, name, lockUuid);
3335    
3336                            try {
3337                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3338                            }
3339                            catch (Exception e) {
3340                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3341                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3342                                    }
3343    
3344                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3345                            }
3346                    }
3347                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3348                            _log.error(se, se);
3349    
3350                            throw se;
3351                    }
3352            }
3353    
3354            public static void unsubscribeFileEntryType(HttpPrincipal httpPrincipal,
3355                    long groupId, long fileEntryTypeId)
3356                    throws com.liferay.portal.kernel.exception.PortalException {
3357                    try {
3358                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3359                                            "unsubscribeFileEntryType",
3360                                            _unsubscribeFileEntryTypeParameterTypes102);
3361    
3362                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
3363                                            fileEntryTypeId);
3364    
3365                            try {
3366                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3367                            }
3368                            catch (Exception e) {
3369                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3370                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3371                                    }
3372    
3373                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3374                            }
3375                    }
3376                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3377                            _log.error(se, se);
3378    
3379                            throw se;
3380                    }
3381            }
3382    
3383            public static void unsubscribeFolder(HttpPrincipal httpPrincipal,
3384                    long groupId, long folderId)
3385                    throws com.liferay.portal.kernel.exception.PortalException {
3386                    try {
3387                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3388                                            "unsubscribeFolder", _unsubscribeFolderParameterTypes103);
3389    
3390                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
3391                                            folderId);
3392    
3393                            try {
3394                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
3395                            }
3396                            catch (Exception e) {
3397                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3398                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3399                                    }
3400    
3401                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3402                            }
3403                    }
3404                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3405                            _log.error(se, se);
3406    
3407                            throw se;
3408                    }
3409            }
3410    
3411            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
3412                    HttpPrincipal httpPrincipal, long fileEntryId,
3413                    java.lang.String sourceFileName, java.lang.String mimeType,
3414                    java.lang.String title, java.lang.String description,
3415                    java.lang.String changeLog, boolean majorVersion, byte[] bytes,
3416                    com.liferay.portal.service.ServiceContext serviceContext)
3417                    throws com.liferay.portal.kernel.exception.PortalException {
3418                    try {
3419                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3420                                            "updateFileEntry", _updateFileEntryParameterTypes104);
3421    
3422                            MethodHandler methodHandler = new MethodHandler(methodKey,
3423                                            fileEntryId, sourceFileName, mimeType, title, description,
3424                                            changeLog, majorVersion, bytes, serviceContext);
3425    
3426                            Object returnObj = null;
3427    
3428                            try {
3429                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3430                            }
3431                            catch (Exception e) {
3432                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3433                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3434                                    }
3435    
3436                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3437                            }
3438    
3439                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3440                    }
3441                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3442                            _log.error(se, se);
3443    
3444                            throw se;
3445                    }
3446            }
3447    
3448            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
3449                    HttpPrincipal httpPrincipal, long fileEntryId,
3450                    java.lang.String sourceFileName, java.lang.String mimeType,
3451                    java.lang.String title, java.lang.String description,
3452                    java.lang.String changeLog, boolean majorVersion, java.io.File file,
3453                    com.liferay.portal.service.ServiceContext serviceContext)
3454                    throws com.liferay.portal.kernel.exception.PortalException {
3455                    try {
3456                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3457                                            "updateFileEntry", _updateFileEntryParameterTypes105);
3458    
3459                            MethodHandler methodHandler = new MethodHandler(methodKey,
3460                                            fileEntryId, sourceFileName, mimeType, title, description,
3461                                            changeLog, majorVersion, file, serviceContext);
3462    
3463                            Object returnObj = null;
3464    
3465                            try {
3466                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3467                            }
3468                            catch (Exception e) {
3469                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3470                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3471                                    }
3472    
3473                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3474                            }
3475    
3476                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3477                    }
3478                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3479                            _log.error(se, se);
3480    
3481                            throw se;
3482                    }
3483            }
3484    
3485            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntry(
3486                    HttpPrincipal httpPrincipal, long fileEntryId,
3487                    java.lang.String sourceFileName, java.lang.String mimeType,
3488                    java.lang.String title, java.lang.String description,
3489                    java.lang.String changeLog, boolean majorVersion,
3490                    java.io.InputStream is, long size,
3491                    com.liferay.portal.service.ServiceContext serviceContext)
3492                    throws com.liferay.portal.kernel.exception.PortalException {
3493                    try {
3494                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3495                                            "updateFileEntry", _updateFileEntryParameterTypes106);
3496    
3497                            MethodHandler methodHandler = new MethodHandler(methodKey,
3498                                            fileEntryId, sourceFileName, mimeType, title, description,
3499                                            changeLog, majorVersion, is, size, serviceContext);
3500    
3501                            Object returnObj = null;
3502    
3503                            try {
3504                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3505                            }
3506                            catch (Exception e) {
3507                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3508                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3509                                    }
3510    
3511                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3512                            }
3513    
3514                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3515                    }
3516                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3517                            _log.error(se, se);
3518    
3519                            throw se;
3520                    }
3521            }
3522    
3523            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
3524                    HttpPrincipal httpPrincipal, long fileEntryId,
3525                    java.lang.String sourceFileName, java.lang.String mimeType,
3526                    java.lang.String title, java.lang.String description,
3527                    java.lang.String changeLog, boolean majorVersion, java.io.File file,
3528                    com.liferay.portal.service.ServiceContext serviceContext)
3529                    throws com.liferay.portal.kernel.exception.PortalException {
3530                    try {
3531                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3532                                            "updateFileEntryAndCheckIn",
3533                                            _updateFileEntryAndCheckInParameterTypes107);
3534    
3535                            MethodHandler methodHandler = new MethodHandler(methodKey,
3536                                            fileEntryId, sourceFileName, mimeType, title, description,
3537                                            changeLog, majorVersion, file, serviceContext);
3538    
3539                            Object returnObj = null;
3540    
3541                            try {
3542                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3543                            }
3544                            catch (Exception e) {
3545                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3546                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3547                                    }
3548    
3549                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3550                            }
3551    
3552                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3553                    }
3554                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3555                            _log.error(se, se);
3556    
3557                            throw se;
3558                    }
3559            }
3560    
3561            public static com.liferay.portal.kernel.repository.model.FileEntry updateFileEntryAndCheckIn(
3562                    HttpPrincipal httpPrincipal, long fileEntryId,
3563                    java.lang.String sourceFileName, java.lang.String mimeType,
3564                    java.lang.String title, java.lang.String description,
3565                    java.lang.String changeLog, boolean majorVersion,
3566                    java.io.InputStream is, long size,
3567                    com.liferay.portal.service.ServiceContext serviceContext)
3568                    throws com.liferay.portal.kernel.exception.PortalException {
3569                    try {
3570                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3571                                            "updateFileEntryAndCheckIn",
3572                                            _updateFileEntryAndCheckInParameterTypes108);
3573    
3574                            MethodHandler methodHandler = new MethodHandler(methodKey,
3575                                            fileEntryId, sourceFileName, mimeType, title, description,
3576                                            changeLog, majorVersion, is, size, serviceContext);
3577    
3578                            Object returnObj = null;
3579    
3580                            try {
3581                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3582                            }
3583                            catch (Exception e) {
3584                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3585                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3586                                    }
3587    
3588                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3589                            }
3590    
3591                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
3592                    }
3593                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3594                            _log.error(se, se);
3595    
3596                            throw se;
3597                    }
3598            }
3599    
3600            public static com.liferay.portlet.documentlibrary.model.DLFileShortcut updateFileShortcut(
3601                    HttpPrincipal httpPrincipal, long fileShortcutId, long folderId,
3602                    long toFileEntryId,
3603                    com.liferay.portal.service.ServiceContext serviceContext)
3604                    throws com.liferay.portal.kernel.exception.PortalException {
3605                    try {
3606                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3607                                            "updateFileShortcut", _updateFileShortcutParameterTypes109);
3608    
3609                            MethodHandler methodHandler = new MethodHandler(methodKey,
3610                                            fileShortcutId, folderId, toFileEntryId, serviceContext);
3611    
3612                            Object returnObj = null;
3613    
3614                            try {
3615                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3616                            }
3617                            catch (Exception e) {
3618                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3619                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3620                                    }
3621    
3622                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3623                            }
3624    
3625                            return (com.liferay.portlet.documentlibrary.model.DLFileShortcut)returnObj;
3626                    }
3627                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3628                            _log.error(se, se);
3629    
3630                            throw se;
3631                    }
3632            }
3633    
3634            public static com.liferay.portal.kernel.repository.model.Folder updateFolder(
3635                    HttpPrincipal httpPrincipal, long folderId, java.lang.String name,
3636                    java.lang.String description,
3637                    com.liferay.portal.service.ServiceContext serviceContext)
3638                    throws com.liferay.portal.kernel.exception.PortalException {
3639                    try {
3640                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3641                                            "updateFolder", _updateFolderParameterTypes110);
3642    
3643                            MethodHandler methodHandler = new MethodHandler(methodKey,
3644                                            folderId, name, description, serviceContext);
3645    
3646                            Object returnObj = null;
3647    
3648                            try {
3649                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3650                            }
3651                            catch (Exception e) {
3652                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3653                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3654                                    }
3655    
3656                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3657                            }
3658    
3659                            return (com.liferay.portal.kernel.repository.model.Folder)returnObj;
3660                    }
3661                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3662                            _log.error(se, se);
3663    
3664                            throw se;
3665                    }
3666            }
3667    
3668            public static boolean verifyFileEntryCheckOut(HttpPrincipal httpPrincipal,
3669                    long repositoryId, long fileEntryId, java.lang.String lockUuid)
3670                    throws com.liferay.portal.kernel.exception.PortalException {
3671                    try {
3672                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3673                                            "verifyFileEntryCheckOut",
3674                                            _verifyFileEntryCheckOutParameterTypes111);
3675    
3676                            MethodHandler methodHandler = new MethodHandler(methodKey,
3677                                            repositoryId, fileEntryId, lockUuid);
3678    
3679                            Object returnObj = null;
3680    
3681                            try {
3682                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3683                            }
3684                            catch (Exception e) {
3685                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3686                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3687                                    }
3688    
3689                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3690                            }
3691    
3692                            return ((Boolean)returnObj).booleanValue();
3693                    }
3694                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3695                            _log.error(se, se);
3696    
3697                            throw se;
3698                    }
3699            }
3700    
3701            public static boolean verifyFileEntryLock(HttpPrincipal httpPrincipal,
3702                    long repositoryId, long fileEntryId, java.lang.String lockUuid)
3703                    throws com.liferay.portal.kernel.exception.PortalException {
3704                    try {
3705                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3706                                            "verifyFileEntryLock", _verifyFileEntryLockParameterTypes112);
3707    
3708                            MethodHandler methodHandler = new MethodHandler(methodKey,
3709                                            repositoryId, fileEntryId, lockUuid);
3710    
3711                            Object returnObj = null;
3712    
3713                            try {
3714                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3715                            }
3716                            catch (Exception e) {
3717                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3718                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3719                                    }
3720    
3721                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3722                            }
3723    
3724                            return ((Boolean)returnObj).booleanValue();
3725                    }
3726                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3727                            _log.error(se, se);
3728    
3729                            throw se;
3730                    }
3731            }
3732    
3733            public static boolean verifyInheritableLock(HttpPrincipal httpPrincipal,
3734                    long repositoryId, long folderId, java.lang.String lockUuid)
3735                    throws com.liferay.portal.kernel.exception.PortalException {
3736                    try {
3737                            MethodKey methodKey = new MethodKey(DLAppServiceUtil.class,
3738                                            "verifyInheritableLock",
3739                                            _verifyInheritableLockParameterTypes113);
3740    
3741                            MethodHandler methodHandler = new MethodHandler(methodKey,
3742                                            repositoryId, folderId, lockUuid);
3743    
3744                            Object returnObj = null;
3745    
3746                            try {
3747                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
3748                            }
3749                            catch (Exception e) {
3750                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
3751                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
3752                                    }
3753    
3754                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
3755                            }
3756    
3757                            return ((Boolean)returnObj).booleanValue();
3758                    }
3759                    catch (com.liferay.portal.kernel.exception.SystemException se) {
3760                            _log.error(se, se);
3761    
3762                            throw se;
3763                    }
3764            }
3765    
3766            private static Log _log = LogFactoryUtil.getLog(DLAppServiceHttp.class);
3767            private static final Class<?>[] _addFileEntryParameterTypes0 = new Class[] {
3768                            long.class, long.class, java.lang.String.class,
3769                            java.lang.String.class, java.lang.String.class,
3770                            java.lang.String.class, java.lang.String.class, byte[].class,
3771                            com.liferay.portal.service.ServiceContext.class
3772                    };
3773            private static final Class<?>[] _addFileEntryParameterTypes1 = new Class[] {
3774                            long.class, long.class, java.lang.String.class,
3775                            java.lang.String.class, java.lang.String.class,
3776                            java.lang.String.class, java.lang.String.class, java.io.File.class,
3777                            com.liferay.portal.service.ServiceContext.class
3778                    };
3779            private static final Class<?>[] _addFileEntryParameterTypes2 = new Class[] {
3780                            long.class, long.class, java.lang.String.class,
3781                            java.lang.String.class, java.lang.String.class,
3782                            java.lang.String.class, java.lang.String.class,
3783                            java.io.InputStream.class, long.class,
3784                            com.liferay.portal.service.ServiceContext.class
3785                    };
3786            private static final Class<?>[] _addFileShortcutParameterTypes3 = new Class[] {
3787                            long.class, long.class, long.class,
3788                            com.liferay.portal.service.ServiceContext.class
3789                    };
3790            private static final Class<?>[] _addFolderParameterTypes4 = new Class[] {
3791                            long.class, long.class, java.lang.String.class,
3792                            java.lang.String.class,
3793                            com.liferay.portal.service.ServiceContext.class
3794                    };
3795            private static final Class<?>[] _addTempFileEntryParameterTypes5 = new Class[] {
3796                            long.class, long.class, java.lang.String.class,
3797                            java.lang.String.class, java.io.File.class, java.lang.String.class
3798                    };
3799            private static final Class<?>[] _addTempFileEntryParameterTypes6 = new Class[] {
3800                            long.class, long.class, java.lang.String.class,
3801                            java.lang.String.class, java.io.InputStream.class,
3802                            java.lang.String.class
3803                    };
3804            private static final Class<?>[] _cancelCheckOutParameterTypes7 = new Class[] {
3805                            long.class
3806                    };
3807            private static final Class<?>[] _checkInFileEntryParameterTypes8 = new Class[] {
3808                            long.class, boolean.class, java.lang.String.class,
3809                            com.liferay.portal.service.ServiceContext.class
3810                    };
3811            private static final Class<?>[] _checkInFileEntryParameterTypes9 = new Class[] {
3812                            long.class, java.lang.String.class
3813                    };
3814            private static final Class<?>[] _checkInFileEntryParameterTypes10 = new Class[] {
3815                            long.class, java.lang.String.class,
3816                            com.liferay.portal.service.ServiceContext.class
3817                    };
3818            private static final Class<?>[] _checkOutFileEntryParameterTypes11 = new Class[] {
3819                            long.class, com.liferay.portal.service.ServiceContext.class
3820                    };
3821            private static final Class<?>[] _checkOutFileEntryParameterTypes12 = new Class[] {
3822                            long.class, java.lang.String.class, long.class,
3823                            com.liferay.portal.service.ServiceContext.class
3824                    };
3825            private static final Class<?>[] _copyFolderParameterTypes13 = new Class[] {
3826                            long.class, long.class, long.class, java.lang.String.class,
3827                            java.lang.String.class,
3828                            com.liferay.portal.service.ServiceContext.class
3829                    };
3830            private static final Class<?>[] _deleteFileEntryParameterTypes14 = new Class[] {
3831                            long.class
3832                    };
3833            private static final Class<?>[] _deleteFileEntryByTitleParameterTypes15 = new Class[] {
3834                            long.class, long.class, java.lang.String.class
3835                    };
3836            private static final Class<?>[] _deleteFileShortcutParameterTypes16 = new Class[] {
3837                            long.class
3838                    };
3839            private static final Class<?>[] _deleteFileVersionParameterTypes17 = new Class[] {
3840                            long.class, java.lang.String.class
3841                    };
3842            private static final Class<?>[] _deleteFolderParameterTypes18 = new Class[] {
3843                            long.class
3844                    };
3845            private static final Class<?>[] _deleteFolderParameterTypes19 = new Class[] {
3846                            long.class, long.class, java.lang.String.class
3847                    };
3848            private static final Class<?>[] _deleteTempFileEntryParameterTypes20 = new Class[] {
3849                            long.class, long.class, java.lang.String.class,
3850                            java.lang.String.class
3851                    };
3852            private static final Class<?>[] _getFileEntriesParameterTypes21 = new Class[] {
3853                            long.class, long.class
3854                    };
3855            private static final Class<?>[] _getFileEntriesParameterTypes22 = new Class[] {
3856                            long.class, long.class, int.class, int.class
3857                    };
3858            private static final Class<?>[] _getFileEntriesParameterTypes23 = new Class[] {
3859                            long.class, long.class, int.class, int.class,
3860                            com.liferay.portal.kernel.util.OrderByComparator.class
3861                    };
3862            private static final Class<?>[] _getFileEntriesParameterTypes24 = new Class[] {
3863                            long.class, long.class, long.class
3864                    };
3865            private static final Class<?>[] _getFileEntriesParameterTypes25 = new Class[] {
3866                            long.class, long.class, long.class, int.class, int.class
3867                    };
3868            private static final Class<?>[] _getFileEntriesParameterTypes26 = new Class[] {
3869                            long.class, long.class, long.class, int.class, int.class,
3870                            com.liferay.portal.kernel.util.OrderByComparator.class
3871                    };
3872            private static final Class<?>[] _getFileEntriesParameterTypes27 = new Class[] {
3873                            long.class, long.class, java.lang.String[].class
3874                    };
3875            private static final Class<?>[] _getFileEntriesParameterTypes28 = new Class[] {
3876                            long.class, long.class, java.lang.String[].class, int.class,
3877                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
3878                    };
3879            private static final Class<?>[] _getFileEntriesAndFileShortcutsParameterTypes29 =
3880                    new Class[] { long.class, long.class, int.class, int.class, int.class };
3881            private static final Class<?>[] _getFileEntriesAndFileShortcutsCountParameterTypes30 =
3882                    new Class[] { long.class, long.class, int.class };
3883            private static final Class<?>[] _getFileEntriesAndFileShortcutsCountParameterTypes31 =
3884                    new Class[] { long.class, long.class, int.class, java.lang.String[].class };
3885            private static final Class<?>[] _getFileEntriesCountParameterTypes32 = new Class[] {
3886                            long.class, long.class
3887                    };
3888            private static final Class<?>[] _getFileEntriesCountParameterTypes33 = new Class[] {
3889                            long.class, long.class, long.class
3890                    };
3891            private static final Class<?>[] _getFileEntriesCountParameterTypes34 = new Class[] {
3892                            long.class, long.class, java.lang.String[].class
3893                    };
3894            private static final Class<?>[] _getFileEntryParameterTypes35 = new Class[] {
3895                            long.class
3896                    };
3897            private static final Class<?>[] _getFileEntryParameterTypes36 = new Class[] {
3898                            long.class, long.class, java.lang.String.class
3899                    };
3900            private static final Class<?>[] _getFileEntryByUuidAndGroupIdParameterTypes37 =
3901                    new Class[] { java.lang.String.class, long.class };
3902            private static final Class<?>[] _getFileShortcutParameterTypes38 = new Class[] {
3903                            long.class
3904                    };
3905            private static final Class<?>[] _getFileVersionParameterTypes39 = new Class[] {
3906                            long.class
3907                    };
3908            private static final Class<?>[] _getFolderParameterTypes40 = new Class[] {
3909                            long.class
3910                    };
3911            private static final Class<?>[] _getFolderParameterTypes41 = new Class[] {
3912                            long.class, long.class, java.lang.String.class
3913                    };
3914            private static final Class<?>[] _getFoldersParameterTypes42 = new Class[] {
3915                            long.class, long.class
3916                    };
3917            private static final Class<?>[] _getFoldersParameterTypes43 = new Class[] {
3918                            long.class, long.class, boolean.class
3919                    };
3920            private static final Class<?>[] _getFoldersParameterTypes44 = new Class[] {
3921                            long.class, long.class, boolean.class, int.class, int.class
3922                    };
3923            private static final Class<?>[] _getFoldersParameterTypes45 = new Class[] {
3924                            long.class, long.class, boolean.class, int.class, int.class,
3925                            com.liferay.portal.kernel.util.OrderByComparator.class
3926                    };
3927            private static final Class<?>[] _getFoldersParameterTypes46 = new Class[] {
3928                            long.class, long.class, int.class, boolean.class, int.class,
3929                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
3930                    };
3931            private static final Class<?>[] _getFoldersParameterTypes47 = new Class[] {
3932                            long.class, long.class, int.class, int.class
3933                    };
3934            private static final Class<?>[] _getFoldersParameterTypes48 = new Class[] {
3935                            long.class, long.class, int.class, int.class,
3936                            com.liferay.portal.kernel.util.OrderByComparator.class
3937                    };
3938            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsParameterTypes49 =
3939                    new Class[] {
3940                            long.class, long.class, int.class, boolean.class, int.class,
3941                            int.class
3942                    };
3943            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsParameterTypes50 =
3944                    new Class[] {
3945                            long.class, long.class, int.class, boolean.class, int.class,
3946                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
3947                    };
3948            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsParameterTypes51 =
3949                    new Class[] {
3950                            long.class, long.class, int.class, java.lang.String[].class,
3951                            boolean.class, int.class, int.class,
3952                            com.liferay.portal.kernel.util.OrderByComparator.class
3953                    };
3954            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsCountParameterTypes52 =
3955                    new Class[] { long.class, long.class, int.class, boolean.class };
3956            private static final Class<?>[] _getFoldersAndFileEntriesAndFileShortcutsCountParameterTypes53 =
3957                    new Class[] {
3958                            long.class, long.class, int.class, java.lang.String[].class,
3959                            boolean.class
3960                    };
3961            private static final Class<?>[] _getFoldersCountParameterTypes54 = new Class[] {
3962                            long.class, long.class
3963                    };
3964            private static final Class<?>[] _getFoldersCountParameterTypes55 = new Class[] {
3965                            long.class, long.class, boolean.class
3966                    };
3967            private static final Class<?>[] _getFoldersCountParameterTypes56 = new Class[] {
3968                            long.class, long.class, int.class, boolean.class
3969                    };
3970            private static final Class<?>[] _getFoldersFileEntriesCountParameterTypes57 = new Class[] {
3971                            long.class, java.util.List.class, int.class
3972                    };
3973            private static final Class<?>[] _getGroupFileEntriesParameterTypes58 = new Class[] {
3974                            long.class, long.class, int.class, int.class
3975                    };
3976            private static final Class<?>[] _getGroupFileEntriesParameterTypes59 = new Class[] {
3977                            long.class, long.class, int.class, int.class,
3978                            com.liferay.portal.kernel.util.OrderByComparator.class
3979                    };
3980            private static final Class<?>[] _getGroupFileEntriesParameterTypes60 = new Class[] {
3981                            long.class, long.class, long.class, int.class, int.class
3982                    };
3983            private static final Class<?>[] _getGroupFileEntriesParameterTypes61 = new Class[] {
3984                            long.class, long.class, long.class, int.class, int.class,
3985                            com.liferay.portal.kernel.util.OrderByComparator.class
3986                    };
3987            private static final Class<?>[] _getGroupFileEntriesParameterTypes62 = new Class[] {
3988                            long.class, long.class, long.class, java.lang.String[].class,
3989                            int.class, int.class, int.class,
3990                            com.liferay.portal.kernel.util.OrderByComparator.class
3991                    };
3992            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes63 = new Class[] {
3993                            long.class, long.class
3994                    };
3995            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes64 = new Class[] {
3996                            long.class, long.class, long.class
3997                    };
3998            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes65 = new Class[] {
3999                            long.class, long.class, long.class, java.lang.String[].class,
4000                            int.class
4001                    };
4002            private static final Class<?>[] _getMountFoldersParameterTypes66 = new Class[] {
4003                            long.class, long.class
4004                    };
4005            private static final Class<?>[] _getMountFoldersParameterTypes67 = new Class[] {
4006                            long.class, long.class, int.class, int.class
4007                    };
4008            private static final Class<?>[] _getMountFoldersParameterTypes68 = new Class[] {
4009                            long.class, long.class, int.class, int.class,
4010                            com.liferay.portal.kernel.util.OrderByComparator.class
4011                    };
4012            private static final Class<?>[] _getMountFoldersCountParameterTypes69 = new Class[] {
4013                            long.class, long.class
4014                    };
4015            private static final Class<?>[] _getSubfolderIdsParameterTypes70 = new Class[] {
4016                            long.class, java.util.List.class, long.class
4017                    };
4018            private static final Class<?>[] _getSubfolderIdsParameterTypes71 = new Class[] {
4019                            long.class, long.class
4020                    };
4021            private static final Class<?>[] _getSubfolderIdsParameterTypes72 = new Class[] {
4022                            long.class, long.class, boolean.class
4023                    };
4024            private static final Class<?>[] _getTempFileNamesParameterTypes73 = new Class[] {
4025                            long.class, long.class, java.lang.String.class
4026                    };
4027            private static final Class<?>[] _lockFileEntryParameterTypes74 = new Class[] {
4028                            long.class
4029                    };
4030            private static final Class<?>[] _lockFileEntryParameterTypes75 = new Class[] {
4031                            long.class, java.lang.String.class, long.class
4032                    };
4033            private static final Class<?>[] _lockFolderParameterTypes76 = new Class[] {
4034                            long.class, long.class
4035                    };
4036            private static final Class<?>[] _lockFolderParameterTypes77 = new Class[] {
4037                            long.class, long.class, java.lang.String.class, boolean.class,
4038                            long.class
4039                    };
4040            private static final Class<?>[] _moveFileEntryParameterTypes78 = new Class[] {
4041                            long.class, long.class,
4042                            com.liferay.portal.service.ServiceContext.class
4043                    };
4044            private static final Class<?>[] _moveFileEntryFromTrashParameterTypes79 = new Class[] {
4045                            long.class, long.class,
4046                            com.liferay.portal.service.ServiceContext.class
4047                    };
4048            private static final Class<?>[] _moveFileEntryToTrashParameterTypes80 = new Class[] {
4049                            long.class
4050                    };
4051            private static final Class<?>[] _moveFileShortcutFromTrashParameterTypes81 = new Class[] {
4052                            long.class, long.class,
4053                            com.liferay.portal.service.ServiceContext.class
4054                    };
4055            private static final Class<?>[] _moveFileShortcutToTrashParameterTypes82 = new Class[] {
4056                            long.class
4057                    };
4058            private static final Class<?>[] _moveFolderParameterTypes83 = new Class[] {
4059                            long.class, long.class,
4060                            com.liferay.portal.service.ServiceContext.class
4061                    };
4062            private static final Class<?>[] _moveFolderFromTrashParameterTypes84 = new Class[] {
4063                            long.class, long.class,
4064                            com.liferay.portal.service.ServiceContext.class
4065                    };
4066            private static final Class<?>[] _moveFolderToTrashParameterTypes85 = new Class[] {
4067                            long.class
4068                    };
4069            private static final Class<?>[] _refreshFileEntryLockParameterTypes86 = new Class[] {
4070                            java.lang.String.class, long.class, long.class
4071                    };
4072            private static final Class<?>[] _refreshFolderLockParameterTypes87 = new Class[] {
4073                            java.lang.String.class, long.class, long.class
4074                    };
4075            private static final Class<?>[] _restoreFileEntryFromTrashParameterTypes88 = new Class[] {
4076                            long.class
4077                    };
4078            private static final Class<?>[] _restoreFileShortcutFromTrashParameterTypes89 =
4079                    new Class[] { long.class };
4080            private static final Class<?>[] _restoreFolderFromTrashParameterTypes90 = new Class[] {
4081                            long.class
4082                    };
4083            private static final Class<?>[] _revertFileEntryParameterTypes91 = new Class[] {
4084                            long.class, java.lang.String.class,
4085                            com.liferay.portal.service.ServiceContext.class
4086                    };
4087            private static final Class<?>[] _searchParameterTypes92 = new Class[] {
4088                            long.class, long.class, int.class, int.class, int.class
4089                    };
4090            private static final Class<?>[] _searchParameterTypes93 = new Class[] {
4091                            long.class, long.class, long.class, java.lang.String[].class,
4092                            int.class, int.class, int.class
4093                    };
4094            private static final Class<?>[] _searchParameterTypes94 = new Class[] {
4095                            long.class, com.liferay.portal.kernel.search.SearchContext.class
4096                    };
4097            private static final Class<?>[] _searchParameterTypes95 = new Class[] {
4098                            long.class, com.liferay.portal.kernel.search.SearchContext.class,
4099                            com.liferay.portal.kernel.search.Query.class
4100                    };
4101            private static final Class<?>[] _subscribeFileEntryTypeParameterTypes96 = new Class[] {
4102                            long.class, long.class
4103                    };
4104            private static final Class<?>[] _subscribeFolderParameterTypes97 = new Class[] {
4105                            long.class, long.class
4106                    };
4107            private static final Class<?>[] _unlockFileEntryParameterTypes98 = new Class[] {
4108                            long.class
4109                    };
4110            private static final Class<?>[] _unlockFileEntryParameterTypes99 = new Class[] {
4111                            long.class, java.lang.String.class
4112                    };
4113            private static final Class<?>[] _unlockFolderParameterTypes100 = new Class[] {
4114                            long.class, long.class, java.lang.String.class
4115                    };
4116            private static final Class<?>[] _unlockFolderParameterTypes101 = new Class[] {
4117                            long.class, long.class, java.lang.String.class,
4118                            java.lang.String.class
4119                    };
4120            private static final Class<?>[] _unsubscribeFileEntryTypeParameterTypes102 = new Class[] {
4121                            long.class, long.class
4122                    };
4123            private static final Class<?>[] _unsubscribeFolderParameterTypes103 = new Class[] {
4124                            long.class, long.class
4125                    };
4126            private static final Class<?>[] _updateFileEntryParameterTypes104 = new Class[] {
4127                            long.class, java.lang.String.class, java.lang.String.class,
4128                            java.lang.String.class, java.lang.String.class,
4129                            java.lang.String.class, boolean.class, byte[].class,
4130                            com.liferay.portal.service.ServiceContext.class
4131                    };
4132            private static final Class<?>[] _updateFileEntryParameterTypes105 = new Class[] {
4133                            long.class, java.lang.String.class, java.lang.String.class,
4134                            java.lang.String.class, java.lang.String.class,
4135                            java.lang.String.class, boolean.class, java.io.File.class,
4136                            com.liferay.portal.service.ServiceContext.class
4137                    };
4138            private static final Class<?>[] _updateFileEntryParameterTypes106 = new Class[] {
4139                            long.class, java.lang.String.class, java.lang.String.class,
4140                            java.lang.String.class, java.lang.String.class,
4141                            java.lang.String.class, boolean.class, java.io.InputStream.class,
4142                            long.class, com.liferay.portal.service.ServiceContext.class
4143                    };
4144            private static final Class<?>[] _updateFileEntryAndCheckInParameterTypes107 = new Class[] {
4145                            long.class, java.lang.String.class, java.lang.String.class,
4146                            java.lang.String.class, java.lang.String.class,
4147                            java.lang.String.class, boolean.class, java.io.File.class,
4148                            com.liferay.portal.service.ServiceContext.class
4149                    };
4150            private static final Class<?>[] _updateFileEntryAndCheckInParameterTypes108 = new Class[] {
4151                            long.class, java.lang.String.class, java.lang.String.class,
4152                            java.lang.String.class, java.lang.String.class,
4153                            java.lang.String.class, boolean.class, java.io.InputStream.class,
4154                            long.class, com.liferay.portal.service.ServiceContext.class
4155                    };
4156            private static final Class<?>[] _updateFileShortcutParameterTypes109 = new Class[] {
4157                            long.class, long.class, long.class,
4158                            com.liferay.portal.service.ServiceContext.class
4159                    };
4160            private static final Class<?>[] _updateFolderParameterTypes110 = new Class[] {
4161                            long.class, java.lang.String.class, java.lang.String.class,
4162                            com.liferay.portal.service.ServiceContext.class
4163                    };
4164            private static final Class<?>[] _verifyFileEntryCheckOutParameterTypes111 = new Class[] {
4165                            long.class, long.class, java.lang.String.class
4166                    };
4167            private static final Class<?>[] _verifyFileEntryLockParameterTypes112 = new Class[] {
4168                            long.class, long.class, java.lang.String.class
4169                    };
4170            private static final Class<?>[] _verifyInheritableLockParameterTypes113 = new Class[] {
4171                            long.class, long.class, java.lang.String.class
4172                    };
4173    }