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