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.document.library.kernel.service.DLFileEntryServiceUtil;
020    
021    import com.liferay.portal.kernel.log.Log;
022    import com.liferay.portal.kernel.log.LogFactoryUtil;
023    import com.liferay.portal.kernel.security.auth.HttpPrincipal;
024    import com.liferay.portal.kernel.service.http.TunnelUtil;
025    import com.liferay.portal.kernel.util.MethodHandler;
026    import com.liferay.portal.kernel.util.MethodKey;
027    
028    /**
029     * Provides the HTTP utility for the
030     * {@link DLFileEntryServiceUtil} 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 DLFileEntryServiceSoap
052     * @see HttpPrincipal
053     * @see DLFileEntryServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class DLFileEntryServiceHttp {
058            public static com.liferay.document.library.kernel.model.DLFileEntry addFileEntry(
059                    HttpPrincipal httpPrincipal, long groupId, long repositoryId,
060                    long folderId, java.lang.String sourceFileName,
061                    java.lang.String mimeType, java.lang.String title,
062                    java.lang.String description, java.lang.String changeLog,
063                    long fileEntryTypeId,
064                    java.util.Map<java.lang.String, com.liferay.dynamic.data.mapping.kernel.DDMFormValues> ddmFormValuesMap,
065                    java.io.File file, java.io.InputStream is, long size,
066                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
067                    throws com.liferay.portal.kernel.exception.PortalException {
068                    try {
069                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
070                                            "addFileEntry", _addFileEntryParameterTypes0);
071    
072                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
073                                            repositoryId, folderId, sourceFileName, mimeType, title,
074                                            description, changeLog, fileEntryTypeId, ddmFormValuesMap,
075                                            file, is, size, serviceContext);
076    
077                            Object returnObj = null;
078    
079                            try {
080                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
081                            }
082                            catch (Exception e) {
083                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
084                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
085                                    }
086    
087                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
088                            }
089    
090                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
091                    }
092                    catch (com.liferay.portal.kernel.exception.SystemException se) {
093                            _log.error(se, se);
094    
095                            throw se;
096                    }
097            }
098    
099            public static com.liferay.document.library.kernel.model.DLFileVersion cancelCheckOut(
100                    HttpPrincipal httpPrincipal, long fileEntryId)
101                    throws com.liferay.portal.kernel.exception.PortalException {
102                    try {
103                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
104                                            "cancelCheckOut", _cancelCheckOutParameterTypes1);
105    
106                            MethodHandler methodHandler = new MethodHandler(methodKey,
107                                            fileEntryId);
108    
109                            Object returnObj = null;
110    
111                            try {
112                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
113                            }
114                            catch (Exception e) {
115                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
116                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
117                                    }
118    
119                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
120                            }
121    
122                            return (com.liferay.document.library.kernel.model.DLFileVersion)returnObj;
123                    }
124                    catch (com.liferay.portal.kernel.exception.SystemException se) {
125                            _log.error(se, se);
126    
127                            throw se;
128                    }
129            }
130    
131            public static void checkInFileEntry(HttpPrincipal httpPrincipal,
132                    long fileEntryId, boolean major, java.lang.String changeLog,
133                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
134                    throws com.liferay.portal.kernel.exception.PortalException {
135                    try {
136                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
137                                            "checkInFileEntry", _checkInFileEntryParameterTypes2);
138    
139                            MethodHandler methodHandler = new MethodHandler(methodKey,
140                                            fileEntryId, major, changeLog, serviceContext);
141    
142                            try {
143                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
144                            }
145                            catch (Exception e) {
146                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
147                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
148                                    }
149    
150                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
151                            }
152                    }
153                    catch (com.liferay.portal.kernel.exception.SystemException se) {
154                            _log.error(se, se);
155    
156                            throw se;
157                    }
158            }
159    
160            public static void checkInFileEntry(HttpPrincipal httpPrincipal,
161                    long fileEntryId, java.lang.String lockUuid,
162                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
163                    throws com.liferay.portal.kernel.exception.PortalException {
164                    try {
165                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
166                                            "checkInFileEntry", _checkInFileEntryParameterTypes3);
167    
168                            MethodHandler methodHandler = new MethodHandler(methodKey,
169                                            fileEntryId, lockUuid, serviceContext);
170    
171                            try {
172                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
173                            }
174                            catch (Exception e) {
175                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
176                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
177                                    }
178    
179                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
180                            }
181                    }
182                    catch (com.liferay.portal.kernel.exception.SystemException se) {
183                            _log.error(se, se);
184    
185                            throw se;
186                    }
187            }
188    
189            public static com.liferay.document.library.kernel.model.DLFileEntry checkOutFileEntry(
190                    HttpPrincipal httpPrincipal, long fileEntryId,
191                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
192                    throws com.liferay.portal.kernel.exception.PortalException {
193                    try {
194                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
195                                            "checkOutFileEntry", _checkOutFileEntryParameterTypes4);
196    
197                            MethodHandler methodHandler = new MethodHandler(methodKey,
198                                            fileEntryId, serviceContext);
199    
200                            Object returnObj = null;
201    
202                            try {
203                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
204                            }
205                            catch (Exception e) {
206                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
207                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
208                                    }
209    
210                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
211                            }
212    
213                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
214                    }
215                    catch (com.liferay.portal.kernel.exception.SystemException se) {
216                            _log.error(se, se);
217    
218                            throw se;
219                    }
220            }
221    
222            public static com.liferay.document.library.kernel.model.DLFileEntry checkOutFileEntry(
223                    HttpPrincipal httpPrincipal, long fileEntryId, java.lang.String owner,
224                    long expirationTime,
225                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
226                    throws com.liferay.portal.kernel.exception.PortalException {
227                    try {
228                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
229                                            "checkOutFileEntry", _checkOutFileEntryParameterTypes5);
230    
231                            MethodHandler methodHandler = new MethodHandler(methodKey,
232                                            fileEntryId, owner, expirationTime, serviceContext);
233    
234                            Object returnObj = null;
235    
236                            try {
237                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
238                            }
239                            catch (Exception e) {
240                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
241                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
242                                    }
243    
244                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
245                            }
246    
247                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
248                    }
249                    catch (com.liferay.portal.kernel.exception.SystemException se) {
250                            _log.error(se, se);
251    
252                            throw se;
253                    }
254            }
255    
256            public static com.liferay.document.library.kernel.model.DLFileEntry copyFileEntry(
257                    HttpPrincipal httpPrincipal, long groupId, long repositoryId,
258                    long fileEntryId, long destFolderId,
259                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
260                    throws com.liferay.portal.kernel.exception.PortalException {
261                    try {
262                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
263                                            "copyFileEntry", _copyFileEntryParameterTypes6);
264    
265                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
266                                            repositoryId, fileEntryId, destFolderId, serviceContext);
267    
268                            Object returnObj = null;
269    
270                            try {
271                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
272                            }
273                            catch (Exception e) {
274                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
275                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
276                                    }
277    
278                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
279                            }
280    
281                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
282                    }
283                    catch (com.liferay.portal.kernel.exception.SystemException se) {
284                            _log.error(se, se);
285    
286                            throw se;
287                    }
288            }
289    
290            public static void deleteFileEntry(HttpPrincipal httpPrincipal,
291                    long fileEntryId)
292                    throws com.liferay.portal.kernel.exception.PortalException {
293                    try {
294                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
295                                            "deleteFileEntry", _deleteFileEntryParameterTypes7);
296    
297                            MethodHandler methodHandler = new MethodHandler(methodKey,
298                                            fileEntryId);
299    
300                            try {
301                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
302                            }
303                            catch (Exception e) {
304                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
305                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
306                                    }
307    
308                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
309                            }
310                    }
311                    catch (com.liferay.portal.kernel.exception.SystemException se) {
312                            _log.error(se, se);
313    
314                            throw se;
315                    }
316            }
317    
318            public static void deleteFileEntry(HttpPrincipal httpPrincipal,
319                    long groupId, long folderId, java.lang.String title)
320                    throws com.liferay.portal.kernel.exception.PortalException {
321                    try {
322                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
323                                            "deleteFileEntry", _deleteFileEntryParameterTypes8);
324    
325                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
326                                            folderId, title);
327    
328                            try {
329                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
330                            }
331                            catch (Exception e) {
332                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
333                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
334                                    }
335    
336                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
337                            }
338                    }
339                    catch (com.liferay.portal.kernel.exception.SystemException se) {
340                            _log.error(se, se);
341    
342                            throw se;
343                    }
344            }
345    
346            public static void deleteFileVersion(HttpPrincipal httpPrincipal,
347                    long fileEntryId, java.lang.String version)
348                    throws com.liferay.portal.kernel.exception.PortalException {
349                    try {
350                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
351                                            "deleteFileVersion", _deleteFileVersionParameterTypes9);
352    
353                            MethodHandler methodHandler = new MethodHandler(methodKey,
354                                            fileEntryId, version);
355    
356                            try {
357                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
358                            }
359                            catch (Exception e) {
360                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
361                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
362                                    }
363    
364                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
365                            }
366                    }
367                    catch (com.liferay.portal.kernel.exception.SystemException se) {
368                            _log.error(se, se);
369    
370                            throw se;
371                    }
372            }
373    
374            public static com.liferay.document.library.kernel.model.DLFileEntry fetchFileEntryByImageId(
375                    HttpPrincipal httpPrincipal, long imageId)
376                    throws com.liferay.portal.kernel.exception.PortalException {
377                    try {
378                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
379                                            "fetchFileEntryByImageId",
380                                            _fetchFileEntryByImageIdParameterTypes10);
381    
382                            MethodHandler methodHandler = new MethodHandler(methodKey, imageId);
383    
384                            Object returnObj = null;
385    
386                            try {
387                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
388                            }
389                            catch (Exception e) {
390                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
391                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
392                                    }
393    
394                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
395                            }
396    
397                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
398                    }
399                    catch (com.liferay.portal.kernel.exception.SystemException se) {
400                            _log.error(se, se);
401    
402                            throw se;
403                    }
404            }
405    
406            public static java.io.InputStream getFileAsStream(
407                    HttpPrincipal httpPrincipal, long fileEntryId, java.lang.String version)
408                    throws com.liferay.portal.kernel.exception.PortalException {
409                    try {
410                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
411                                            "getFileAsStream", _getFileAsStreamParameterTypes11);
412    
413                            MethodHandler methodHandler = new MethodHandler(methodKey,
414                                            fileEntryId, version);
415    
416                            Object returnObj = null;
417    
418                            try {
419                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
420                            }
421                            catch (Exception e) {
422                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
423                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
424                                    }
425    
426                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
427                            }
428    
429                            return (java.io.InputStream)returnObj;
430                    }
431                    catch (com.liferay.portal.kernel.exception.SystemException se) {
432                            _log.error(se, se);
433    
434                            throw se;
435                    }
436            }
437    
438            public static java.io.InputStream getFileAsStream(
439                    HttpPrincipal httpPrincipal, long fileEntryId,
440                    java.lang.String version, boolean incrementCounter)
441                    throws com.liferay.portal.kernel.exception.PortalException {
442                    try {
443                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
444                                            "getFileAsStream", _getFileAsStreamParameterTypes12);
445    
446                            MethodHandler methodHandler = new MethodHandler(methodKey,
447                                            fileEntryId, version, incrementCounter);
448    
449                            Object returnObj = null;
450    
451                            try {
452                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
453                            }
454                            catch (Exception e) {
455                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
456                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
457                                    }
458    
459                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
460                            }
461    
462                            return (java.io.InputStream)returnObj;
463                    }
464                    catch (com.liferay.portal.kernel.exception.SystemException se) {
465                            _log.error(se, se);
466    
467                            throw se;
468                    }
469            }
470    
471            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getFileEntries(
472                    HttpPrincipal httpPrincipal, long groupId, long folderId, int status,
473                    int start, int end,
474                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
475                    throws com.liferay.portal.kernel.exception.PortalException {
476                    try {
477                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
478                                            "getFileEntries", _getFileEntriesParameterTypes13);
479    
480                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
481                                            folderId, status, start, end, obc);
482    
483                            Object returnObj = null;
484    
485                            try {
486                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
487                            }
488                            catch (Exception e) {
489                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
490                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
491                                    }
492    
493                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
494                            }
495    
496                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
497                    }
498                    catch (com.liferay.portal.kernel.exception.SystemException se) {
499                            _log.error(se, se);
500    
501                            throw se;
502                    }
503            }
504    
505            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getFileEntries(
506                    HttpPrincipal httpPrincipal, long groupId, long folderId, int start,
507                    int end,
508                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
509                    throws com.liferay.portal.kernel.exception.PortalException {
510                    try {
511                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
512                                            "getFileEntries", _getFileEntriesParameterTypes14);
513    
514                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
515                                            folderId, start, end, obc);
516    
517                            Object returnObj = null;
518    
519                            try {
520                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
521                            }
522                            catch (Exception e) {
523                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
524                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
525                                    }
526    
527                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
528                            }
529    
530                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
531                    }
532                    catch (com.liferay.portal.kernel.exception.SystemException se) {
533                            _log.error(se, se);
534    
535                            throw se;
536                    }
537            }
538    
539            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getFileEntries(
540                    HttpPrincipal httpPrincipal, long groupId, long folderId,
541                    long fileEntryTypeId, int start, int end,
542                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
543                    throws com.liferay.portal.kernel.exception.PortalException {
544                    try {
545                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
546                                            "getFileEntries", _getFileEntriesParameterTypes15);
547    
548                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
549                                            folderId, fileEntryTypeId, start, end, obc);
550    
551                            Object returnObj = null;
552    
553                            try {
554                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
555                            }
556                            catch (Exception e) {
557                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
558                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
559                                    }
560    
561                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
562                            }
563    
564                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
565                    }
566                    catch (com.liferay.portal.kernel.exception.SystemException se) {
567                            _log.error(se, se);
568    
569                            throw se;
570                    }
571            }
572    
573            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getFileEntries(
574                    HttpPrincipal httpPrincipal, long groupId, long folderId,
575                    java.lang.String[] mimeTypes, int start, int end,
576                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
577                    throws com.liferay.portal.kernel.exception.PortalException {
578                    try {
579                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
580                                            "getFileEntries", _getFileEntriesParameterTypes16);
581    
582                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
583                                            folderId, mimeTypes, start, end, obc);
584    
585                            Object returnObj = null;
586    
587                            try {
588                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
589                            }
590                            catch (Exception e) {
591                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
592                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
593                                    }
594    
595                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
596                            }
597    
598                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
599                    }
600                    catch (com.liferay.portal.kernel.exception.SystemException se) {
601                            _log.error(se, se);
602    
603                            throw se;
604                    }
605            }
606    
607            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
608                    long groupId, long folderId) {
609                    try {
610                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
611                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes17);
612    
613                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
614                                            folderId);
615    
616                            Object returnObj = null;
617    
618                            try {
619                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
620                            }
621                            catch (Exception e) {
622                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
623                            }
624    
625                            return ((Integer)returnObj).intValue();
626                    }
627                    catch (com.liferay.portal.kernel.exception.SystemException se) {
628                            _log.error(se, se);
629    
630                            throw se;
631                    }
632            }
633    
634            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
635                    long groupId, long folderId, int status) {
636                    try {
637                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
638                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes18);
639    
640                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
641                                            folderId, status);
642    
643                            Object returnObj = null;
644    
645                            try {
646                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
647                            }
648                            catch (Exception e) {
649                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
650                            }
651    
652                            return ((Integer)returnObj).intValue();
653                    }
654                    catch (com.liferay.portal.kernel.exception.SystemException se) {
655                            _log.error(se, se);
656    
657                            throw se;
658                    }
659            }
660    
661            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
662                    long groupId, long folderId, long fileEntryTypeId) {
663                    try {
664                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
665                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes19);
666    
667                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
668                                            folderId, fileEntryTypeId);
669    
670                            Object returnObj = null;
671    
672                            try {
673                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
674                            }
675                            catch (Exception e) {
676                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
677                            }
678    
679                            return ((Integer)returnObj).intValue();
680                    }
681                    catch (com.liferay.portal.kernel.exception.SystemException se) {
682                            _log.error(se, se);
683    
684                            throw se;
685                    }
686            }
687    
688            public static int getFileEntriesCount(HttpPrincipal httpPrincipal,
689                    long groupId, long folderId, java.lang.String[] mimeTypes) {
690                    try {
691                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
692                                            "getFileEntriesCount", _getFileEntriesCountParameterTypes20);
693    
694                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
695                                            folderId, mimeTypes);
696    
697                            Object returnObj = null;
698    
699                            try {
700                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
701                            }
702                            catch (Exception e) {
703                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
704                            }
705    
706                            return ((Integer)returnObj).intValue();
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 com.liferay.document.library.kernel.model.DLFileEntry getFileEntry(
716                    HttpPrincipal httpPrincipal, long fileEntryId)
717                    throws com.liferay.portal.kernel.exception.PortalException {
718                    try {
719                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
720                                            "getFileEntry", _getFileEntryParameterTypes21);
721    
722                            MethodHandler methodHandler = new MethodHandler(methodKey,
723                                            fileEntryId);
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 (com.liferay.document.library.kernel.model.DLFileEntry)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 com.liferay.document.library.kernel.model.DLFileEntry getFileEntry(
748                    HttpPrincipal httpPrincipal, long groupId, long folderId,
749                    java.lang.String title)
750                    throws com.liferay.portal.kernel.exception.PortalException {
751                    try {
752                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
753                                            "getFileEntry", _getFileEntryParameterTypes22);
754    
755                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
756                                            folderId, title);
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 (com.liferay.document.library.kernel.model.DLFileEntry)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 com.liferay.document.library.kernel.model.DLFileEntry getFileEntryByUuidAndGroupId(
781                    HttpPrincipal httpPrincipal, java.lang.String uuid, long groupId)
782                    throws com.liferay.portal.kernel.exception.PortalException {
783                    try {
784                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
785                                            "getFileEntryByUuidAndGroupId",
786                                            _getFileEntryByUuidAndGroupIdParameterTypes23);
787    
788                            MethodHandler methodHandler = new MethodHandler(methodKey, uuid,
789                                            groupId);
790    
791                            Object returnObj = null;
792    
793                            try {
794                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
795                            }
796                            catch (Exception e) {
797                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
798                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
799                                    }
800    
801                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
802                            }
803    
804                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
805                    }
806                    catch (com.liferay.portal.kernel.exception.SystemException se) {
807                            _log.error(se, se);
808    
809                            throw se;
810                    }
811            }
812    
813            public static com.liferay.portal.kernel.lock.Lock getFileEntryLock(
814                    HttpPrincipal httpPrincipal, long fileEntryId) {
815                    try {
816                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
817                                            "getFileEntryLock", _getFileEntryLockParameterTypes24);
818    
819                            MethodHandler methodHandler = new MethodHandler(methodKey,
820                                            fileEntryId);
821    
822                            Object returnObj = null;
823    
824                            try {
825                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
826                            }
827                            catch (Exception e) {
828                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
829                            }
830    
831                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
832                    }
833                    catch (com.liferay.portal.kernel.exception.SystemException se) {
834                            _log.error(se, se);
835    
836                            throw se;
837                    }
838            }
839    
840            public static int getFoldersFileEntriesCount(HttpPrincipal httpPrincipal,
841                    long groupId, java.util.List<java.lang.Long> folderIds, int status) {
842                    try {
843                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
844                                            "getFoldersFileEntriesCount",
845                                            _getFoldersFileEntriesCountParameterTypes25);
846    
847                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
848                                            folderIds, status);
849    
850                            Object returnObj = null;
851    
852                            try {
853                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
854                            }
855                            catch (Exception e) {
856                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
857                            }
858    
859                            return ((Integer)returnObj).intValue();
860                    }
861                    catch (com.liferay.portal.kernel.exception.SystemException se) {
862                            _log.error(se, se);
863    
864                            throw se;
865                    }
866            }
867    
868            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getGroupFileEntries(
869                    HttpPrincipal httpPrincipal, long groupId, long userId,
870                    long rootFolderId, int start, int end,
871                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
872                    throws com.liferay.portal.kernel.exception.PortalException {
873                    try {
874                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
875                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes26);
876    
877                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
878                                            userId, rootFolderId, start, end, obc);
879    
880                            Object returnObj = null;
881    
882                            try {
883                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
884                            }
885                            catch (Exception e) {
886                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
887                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
888                                    }
889    
890                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
891                            }
892    
893                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
894                    }
895                    catch (com.liferay.portal.kernel.exception.SystemException se) {
896                            _log.error(se, se);
897    
898                            throw se;
899                    }
900            }
901    
902            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getGroupFileEntries(
903                    HttpPrincipal httpPrincipal, long groupId, long userId,
904                    long repositoryId, long rootFolderId, java.lang.String[] mimeTypes,
905                    int status, int start, int end,
906                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
907                    throws com.liferay.portal.kernel.exception.PortalException {
908                    try {
909                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
910                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes27);
911    
912                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
913                                            userId, repositoryId, rootFolderId, mimeTypes, status,
914                                            start, end, obc);
915    
916                            Object returnObj = null;
917    
918                            try {
919                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
920                            }
921                            catch (Exception e) {
922                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
923                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
924                                    }
925    
926                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
927                            }
928    
929                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
930                    }
931                    catch (com.liferay.portal.kernel.exception.SystemException se) {
932                            _log.error(se, se);
933    
934                            throw se;
935                    }
936            }
937    
938            public static java.util.List<com.liferay.document.library.kernel.model.DLFileEntry> getGroupFileEntries(
939                    HttpPrincipal httpPrincipal, long groupId, long userId,
940                    long rootFolderId, java.lang.String[] mimeTypes, int status, int start,
941                    int end,
942                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntry> obc)
943                    throws com.liferay.portal.kernel.exception.PortalException {
944                    try {
945                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
946                                            "getGroupFileEntries", _getGroupFileEntriesParameterTypes28);
947    
948                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
949                                            userId, rootFolderId, mimeTypes, status, start, end, obc);
950    
951                            Object returnObj = null;
952    
953                            try {
954                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
955                            }
956                            catch (Exception e) {
957                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
958                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
959                                    }
960    
961                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
962                            }
963    
964                            return (java.util.List<com.liferay.document.library.kernel.model.DLFileEntry>)returnObj;
965                    }
966                    catch (com.liferay.portal.kernel.exception.SystemException se) {
967                            _log.error(se, se);
968    
969                            throw se;
970                    }
971            }
972    
973            public static int getGroupFileEntriesCount(HttpPrincipal httpPrincipal,
974                    long groupId, long userId, long rootFolderId)
975                    throws com.liferay.portal.kernel.exception.PortalException {
976                    try {
977                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
978                                            "getGroupFileEntriesCount",
979                                            _getGroupFileEntriesCountParameterTypes29);
980    
981                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
982                                            userId, rootFolderId);
983    
984                            Object returnObj = null;
985    
986                            try {
987                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
988                            }
989                            catch (Exception e) {
990                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
991                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
992                                    }
993    
994                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
995                            }
996    
997                            return ((Integer)returnObj).intValue();
998                    }
999                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1000                            _log.error(se, se);
1001    
1002                            throw se;
1003                    }
1004            }
1005    
1006            public static int getGroupFileEntriesCount(HttpPrincipal httpPrincipal,
1007                    long groupId, long userId, long repositoryId, long rootFolderId,
1008                    java.lang.String[] mimeTypes, int status)
1009                    throws com.liferay.portal.kernel.exception.PortalException {
1010                    try {
1011                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1012                                            "getGroupFileEntriesCount",
1013                                            _getGroupFileEntriesCountParameterTypes30);
1014    
1015                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1016                                            userId, repositoryId, rootFolderId, mimeTypes, status);
1017    
1018                            Object returnObj = null;
1019    
1020                            try {
1021                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1022                            }
1023                            catch (Exception e) {
1024                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1025                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1026                                    }
1027    
1028                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1029                            }
1030    
1031                            return ((Integer)returnObj).intValue();
1032                    }
1033                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1034                            _log.error(se, se);
1035    
1036                            throw se;
1037                    }
1038            }
1039    
1040            public static int getGroupFileEntriesCount(HttpPrincipal httpPrincipal,
1041                    long groupId, long userId, long rootFolderId,
1042                    java.lang.String[] mimeTypes, int status)
1043                    throws com.liferay.portal.kernel.exception.PortalException {
1044                    try {
1045                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1046                                            "getGroupFileEntriesCount",
1047                                            _getGroupFileEntriesCountParameterTypes31);
1048    
1049                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1050                                            userId, rootFolderId, mimeTypes, status);
1051    
1052                            Object returnObj = null;
1053    
1054                            try {
1055                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1056                            }
1057                            catch (Exception e) {
1058                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1059                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1060                                    }
1061    
1062                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1063                            }
1064    
1065                            return ((Integer)returnObj).intValue();
1066                    }
1067                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1068                            _log.error(se, se);
1069    
1070                            throw se;
1071                    }
1072            }
1073    
1074            public static boolean hasFileEntryLock(HttpPrincipal httpPrincipal,
1075                    long fileEntryId)
1076                    throws com.liferay.portal.kernel.exception.PortalException {
1077                    try {
1078                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1079                                            "hasFileEntryLock", _hasFileEntryLockParameterTypes32);
1080    
1081                            MethodHandler methodHandler = new MethodHandler(methodKey,
1082                                            fileEntryId);
1083    
1084                            Object returnObj = null;
1085    
1086                            try {
1087                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1088                            }
1089                            catch (Exception e) {
1090                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1091                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1092                                    }
1093    
1094                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1095                            }
1096    
1097                            return ((Boolean)returnObj).booleanValue();
1098                    }
1099                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1100                            _log.error(se, se);
1101    
1102                            throw se;
1103                    }
1104            }
1105    
1106            public static boolean isFileEntryCheckedOut(HttpPrincipal httpPrincipal,
1107                    long fileEntryId)
1108                    throws com.liferay.portal.kernel.exception.PortalException {
1109                    try {
1110                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1111                                            "isFileEntryCheckedOut",
1112                                            _isFileEntryCheckedOutParameterTypes33);
1113    
1114                            MethodHandler methodHandler = new MethodHandler(methodKey,
1115                                            fileEntryId);
1116    
1117                            Object returnObj = null;
1118    
1119                            try {
1120                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1121                            }
1122                            catch (Exception e) {
1123                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1124                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1125                                    }
1126    
1127                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1128                            }
1129    
1130                            return ((Boolean)returnObj).booleanValue();
1131                    }
1132                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1133                            _log.error(se, se);
1134    
1135                            throw se;
1136                    }
1137            }
1138    
1139            public static boolean isKeepFileVersionLabel(HttpPrincipal httpPrincipal,
1140                    long fileEntryId,
1141                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1142                    throws com.liferay.portal.kernel.exception.PortalException {
1143                    try {
1144                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1145                                            "isKeepFileVersionLabel",
1146                                            _isKeepFileVersionLabelParameterTypes34);
1147    
1148                            MethodHandler methodHandler = new MethodHandler(methodKey,
1149                                            fileEntryId, serviceContext);
1150    
1151                            Object returnObj = null;
1152    
1153                            try {
1154                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1155                            }
1156                            catch (Exception e) {
1157                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1158                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1159                                    }
1160    
1161                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1162                            }
1163    
1164                            return ((Boolean)returnObj).booleanValue();
1165                    }
1166                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1167                            _log.error(se, se);
1168    
1169                            throw se;
1170                    }
1171            }
1172    
1173            public static com.liferay.document.library.kernel.model.DLFileEntry moveFileEntry(
1174                    HttpPrincipal httpPrincipal, long fileEntryId, long newFolderId,
1175                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1176                    throws com.liferay.portal.kernel.exception.PortalException {
1177                    try {
1178                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1179                                            "moveFileEntry", _moveFileEntryParameterTypes35);
1180    
1181                            MethodHandler methodHandler = new MethodHandler(methodKey,
1182                                            fileEntryId, newFolderId, serviceContext);
1183    
1184                            Object returnObj = null;
1185    
1186                            try {
1187                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1188                            }
1189                            catch (Exception e) {
1190                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1191                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1192                                    }
1193    
1194                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1195                            }
1196    
1197                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
1198                    }
1199                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1200                            _log.error(se, se);
1201    
1202                            throw se;
1203                    }
1204            }
1205    
1206            public static com.liferay.portal.kernel.lock.Lock refreshFileEntryLock(
1207                    HttpPrincipal httpPrincipal, java.lang.String lockUuid, long companyId,
1208                    long expirationTime)
1209                    throws com.liferay.portal.kernel.exception.PortalException {
1210                    try {
1211                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1212                                            "refreshFileEntryLock",
1213                                            _refreshFileEntryLockParameterTypes36);
1214    
1215                            MethodHandler methodHandler = new MethodHandler(methodKey,
1216                                            lockUuid, companyId, expirationTime);
1217    
1218                            Object returnObj = null;
1219    
1220                            try {
1221                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1222                            }
1223                            catch (Exception e) {
1224                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1225                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1226                                    }
1227    
1228                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1229                            }
1230    
1231                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
1232                    }
1233                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1234                            _log.error(se, se);
1235    
1236                            throw se;
1237                    }
1238            }
1239    
1240            public static void revertFileEntry(HttpPrincipal httpPrincipal,
1241                    long fileEntryId, java.lang.String version,
1242                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1243                    throws com.liferay.portal.kernel.exception.PortalException {
1244                    try {
1245                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1246                                            "revertFileEntry", _revertFileEntryParameterTypes37);
1247    
1248                            MethodHandler methodHandler = new MethodHandler(methodKey,
1249                                            fileEntryId, version, serviceContext);
1250    
1251                            try {
1252                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1253                            }
1254                            catch (Exception e) {
1255                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1256                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1257                                    }
1258    
1259                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1260                            }
1261                    }
1262                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1263                            _log.error(se, se);
1264    
1265                            throw se;
1266                    }
1267            }
1268    
1269            public static com.liferay.portal.kernel.search.Hits search(
1270                    HttpPrincipal httpPrincipal, long groupId, long creatorUserId,
1271                    int status, int start, int end)
1272                    throws com.liferay.portal.kernel.exception.PortalException {
1273                    try {
1274                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1275                                            "search", _searchParameterTypes38);
1276    
1277                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1278                                            creatorUserId, status, start, end);
1279    
1280                            Object returnObj = null;
1281    
1282                            try {
1283                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1284                            }
1285                            catch (Exception e) {
1286                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1287                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1288                                    }
1289    
1290                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1291                            }
1292    
1293                            return (com.liferay.portal.kernel.search.Hits)returnObj;
1294                    }
1295                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1296                            _log.error(se, se);
1297    
1298                            throw se;
1299                    }
1300            }
1301    
1302            public static com.liferay.portal.kernel.search.Hits search(
1303                    HttpPrincipal httpPrincipal, long groupId, long creatorUserId,
1304                    long folderId, java.lang.String[] mimeTypes, int status, int start,
1305                    int end) throws com.liferay.portal.kernel.exception.PortalException {
1306                    try {
1307                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1308                                            "search", _searchParameterTypes39);
1309    
1310                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1311                                            creatorUserId, folderId, mimeTypes, status, start, end);
1312    
1313                            Object returnObj = null;
1314    
1315                            try {
1316                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1317                            }
1318                            catch (Exception e) {
1319                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1320                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1321                                    }
1322    
1323                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1324                            }
1325    
1326                            return (com.liferay.portal.kernel.search.Hits)returnObj;
1327                    }
1328                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1329                            _log.error(se, se);
1330    
1331                            throw se;
1332                    }
1333            }
1334    
1335            public static com.liferay.document.library.kernel.model.DLFileEntry updateFileEntry(
1336                    HttpPrincipal httpPrincipal, long fileEntryId,
1337                    java.lang.String sourceFileName, java.lang.String mimeType,
1338                    java.lang.String title, java.lang.String description,
1339                    java.lang.String changeLog, boolean majorVersion, long fileEntryTypeId,
1340                    java.util.Map<java.lang.String, com.liferay.dynamic.data.mapping.kernel.DDMFormValues> ddmFormValuesMap,
1341                    java.io.File file, java.io.InputStream is, long size,
1342                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1343                    throws com.liferay.portal.kernel.exception.PortalException {
1344                    try {
1345                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1346                                            "updateFileEntry", _updateFileEntryParameterTypes40);
1347    
1348                            MethodHandler methodHandler = new MethodHandler(methodKey,
1349                                            fileEntryId, sourceFileName, mimeType, title, description,
1350                                            changeLog, majorVersion, fileEntryTypeId, ddmFormValuesMap,
1351                                            file, is, size, serviceContext);
1352    
1353                            Object returnObj = null;
1354    
1355                            try {
1356                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1357                            }
1358                            catch (Exception e) {
1359                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1360                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1361                                    }
1362    
1363                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1364                            }
1365    
1366                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
1367                    }
1368                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1369                            _log.error(se, se);
1370    
1371                            throw se;
1372                    }
1373            }
1374    
1375            public static com.liferay.document.library.kernel.model.DLFileEntry updateStatus(
1376                    HttpPrincipal httpPrincipal, long userId, long fileVersionId,
1377                    int status,
1378                    com.liferay.portal.kernel.service.ServiceContext serviceContext,
1379                    java.util.Map<java.lang.String, java.io.Serializable> workflowContext)
1380                    throws com.liferay.portal.kernel.exception.PortalException {
1381                    try {
1382                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1383                                            "updateStatus", _updateStatusParameterTypes41);
1384    
1385                            MethodHandler methodHandler = new MethodHandler(methodKey, userId,
1386                                            fileVersionId, status, serviceContext, workflowContext);
1387    
1388                            Object returnObj = null;
1389    
1390                            try {
1391                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1392                            }
1393                            catch (Exception e) {
1394                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1395                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1396                                    }
1397    
1398                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1399                            }
1400    
1401                            return (com.liferay.document.library.kernel.model.DLFileEntry)returnObj;
1402                    }
1403                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1404                            _log.error(se, se);
1405    
1406                            throw se;
1407                    }
1408            }
1409    
1410            public static boolean verifyFileEntryCheckOut(HttpPrincipal httpPrincipal,
1411                    long fileEntryId, java.lang.String lockUuid)
1412                    throws com.liferay.portal.kernel.exception.PortalException {
1413                    try {
1414                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1415                                            "verifyFileEntryCheckOut",
1416                                            _verifyFileEntryCheckOutParameterTypes42);
1417    
1418                            MethodHandler methodHandler = new MethodHandler(methodKey,
1419                                            fileEntryId, lockUuid);
1420    
1421                            Object returnObj = null;
1422    
1423                            try {
1424                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1425                            }
1426                            catch (Exception e) {
1427                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1428                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1429                                    }
1430    
1431                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1432                            }
1433    
1434                            return ((Boolean)returnObj).booleanValue();
1435                    }
1436                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1437                            _log.error(se, se);
1438    
1439                            throw se;
1440                    }
1441            }
1442    
1443            public static boolean verifyFileEntryLock(HttpPrincipal httpPrincipal,
1444                    long fileEntryId, java.lang.String lockUuid)
1445                    throws com.liferay.portal.kernel.exception.PortalException {
1446                    try {
1447                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1448                                            "verifyFileEntryLock", _verifyFileEntryLockParameterTypes43);
1449    
1450                            MethodHandler methodHandler = new MethodHandler(methodKey,
1451                                            fileEntryId, lockUuid);
1452    
1453                            Object returnObj = null;
1454    
1455                            try {
1456                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1457                            }
1458                            catch (Exception e) {
1459                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1460                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1461                                    }
1462    
1463                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1464                            }
1465    
1466                            return ((Boolean)returnObj).booleanValue();
1467                    }
1468                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1469                            _log.error(se, se);
1470    
1471                            throw se;
1472                    }
1473            }
1474    
1475            private static Log _log = LogFactoryUtil.getLog(DLFileEntryServiceHttp.class);
1476            private static final Class<?>[] _addFileEntryParameterTypes0 = new Class[] {
1477                            long.class, long.class, long.class, java.lang.String.class,
1478                            java.lang.String.class, java.lang.String.class,
1479                            java.lang.String.class, java.lang.String.class, long.class,
1480                            java.util.Map.class, java.io.File.class, java.io.InputStream.class,
1481                            long.class, com.liferay.portal.kernel.service.ServiceContext.class
1482                    };
1483            private static final Class<?>[] _cancelCheckOutParameterTypes1 = new Class[] {
1484                            long.class
1485                    };
1486            private static final Class<?>[] _checkInFileEntryParameterTypes2 = new Class[] {
1487                            long.class, boolean.class, java.lang.String.class,
1488                            com.liferay.portal.kernel.service.ServiceContext.class
1489                    };
1490            private static final Class<?>[] _checkInFileEntryParameterTypes3 = new Class[] {
1491                            long.class, java.lang.String.class,
1492                            com.liferay.portal.kernel.service.ServiceContext.class
1493                    };
1494            private static final Class<?>[] _checkOutFileEntryParameterTypes4 = new Class[] {
1495                            long.class, com.liferay.portal.kernel.service.ServiceContext.class
1496                    };
1497            private static final Class<?>[] _checkOutFileEntryParameterTypes5 = new Class[] {
1498                            long.class, java.lang.String.class, long.class,
1499                            com.liferay.portal.kernel.service.ServiceContext.class
1500                    };
1501            private static final Class<?>[] _copyFileEntryParameterTypes6 = new Class[] {
1502                            long.class, long.class, long.class, long.class,
1503                            com.liferay.portal.kernel.service.ServiceContext.class
1504                    };
1505            private static final Class<?>[] _deleteFileEntryParameterTypes7 = new Class[] {
1506                            long.class
1507                    };
1508            private static final Class<?>[] _deleteFileEntryParameterTypes8 = new Class[] {
1509                            long.class, long.class, java.lang.String.class
1510                    };
1511            private static final Class<?>[] _deleteFileVersionParameterTypes9 = new Class[] {
1512                            long.class, java.lang.String.class
1513                    };
1514            private static final Class<?>[] _fetchFileEntryByImageIdParameterTypes10 = new Class[] {
1515                            long.class
1516                    };
1517            private static final Class<?>[] _getFileAsStreamParameterTypes11 = new Class[] {
1518                            long.class, java.lang.String.class
1519                    };
1520            private static final Class<?>[] _getFileAsStreamParameterTypes12 = new Class[] {
1521                            long.class, java.lang.String.class, boolean.class
1522                    };
1523            private static final Class<?>[] _getFileEntriesParameterTypes13 = new Class[] {
1524                            long.class, long.class, int.class, int.class, int.class,
1525                            com.liferay.portal.kernel.util.OrderByComparator.class
1526                    };
1527            private static final Class<?>[] _getFileEntriesParameterTypes14 = new Class[] {
1528                            long.class, long.class, int.class, int.class,
1529                            com.liferay.portal.kernel.util.OrderByComparator.class
1530                    };
1531            private static final Class<?>[] _getFileEntriesParameterTypes15 = new Class[] {
1532                            long.class, long.class, long.class, int.class, int.class,
1533                            com.liferay.portal.kernel.util.OrderByComparator.class
1534                    };
1535            private static final Class<?>[] _getFileEntriesParameterTypes16 = new Class[] {
1536                            long.class, long.class, java.lang.String[].class, int.class,
1537                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
1538                    };
1539            private static final Class<?>[] _getFileEntriesCountParameterTypes17 = new Class[] {
1540                            long.class, long.class
1541                    };
1542            private static final Class<?>[] _getFileEntriesCountParameterTypes18 = new Class[] {
1543                            long.class, long.class, int.class
1544                    };
1545            private static final Class<?>[] _getFileEntriesCountParameterTypes19 = new Class[] {
1546                            long.class, long.class, long.class
1547                    };
1548            private static final Class<?>[] _getFileEntriesCountParameterTypes20 = new Class[] {
1549                            long.class, long.class, java.lang.String[].class
1550                    };
1551            private static final Class<?>[] _getFileEntryParameterTypes21 = new Class[] {
1552                            long.class
1553                    };
1554            private static final Class<?>[] _getFileEntryParameterTypes22 = new Class[] {
1555                            long.class, long.class, java.lang.String.class
1556                    };
1557            private static final Class<?>[] _getFileEntryByUuidAndGroupIdParameterTypes23 =
1558                    new Class[] { java.lang.String.class, long.class };
1559            private static final Class<?>[] _getFileEntryLockParameterTypes24 = new Class[] {
1560                            long.class
1561                    };
1562            private static final Class<?>[] _getFoldersFileEntriesCountParameterTypes25 = new Class[] {
1563                            long.class, java.util.List.class, int.class
1564                    };
1565            private static final Class<?>[] _getGroupFileEntriesParameterTypes26 = new Class[] {
1566                            long.class, long.class, long.class, int.class, int.class,
1567                            com.liferay.portal.kernel.util.OrderByComparator.class
1568                    };
1569            private static final Class<?>[] _getGroupFileEntriesParameterTypes27 = new Class[] {
1570                            long.class, long.class, long.class, long.class,
1571                            java.lang.String[].class, int.class, int.class, int.class,
1572                            com.liferay.portal.kernel.util.OrderByComparator.class
1573                    };
1574            private static final Class<?>[] _getGroupFileEntriesParameterTypes28 = new Class[] {
1575                            long.class, long.class, long.class, java.lang.String[].class,
1576                            int.class, int.class, int.class,
1577                            com.liferay.portal.kernel.util.OrderByComparator.class
1578                    };
1579            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes29 = new Class[] {
1580                            long.class, long.class, long.class
1581                    };
1582            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes30 = new Class[] {
1583                            long.class, long.class, long.class, long.class,
1584                            java.lang.String[].class, int.class
1585                    };
1586            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes31 = new Class[] {
1587                            long.class, long.class, long.class, java.lang.String[].class,
1588                            int.class
1589                    };
1590            private static final Class<?>[] _hasFileEntryLockParameterTypes32 = new Class[] {
1591                            long.class
1592                    };
1593            private static final Class<?>[] _isFileEntryCheckedOutParameterTypes33 = new Class[] {
1594                            long.class
1595                    };
1596            private static final Class<?>[] _isKeepFileVersionLabelParameterTypes34 = new Class[] {
1597                            long.class, com.liferay.portal.kernel.service.ServiceContext.class
1598                    };
1599            private static final Class<?>[] _moveFileEntryParameterTypes35 = new Class[] {
1600                            long.class, long.class,
1601                            com.liferay.portal.kernel.service.ServiceContext.class
1602                    };
1603            private static final Class<?>[] _refreshFileEntryLockParameterTypes36 = new Class[] {
1604                            java.lang.String.class, long.class, long.class
1605                    };
1606            private static final Class<?>[] _revertFileEntryParameterTypes37 = new Class[] {
1607                            long.class, java.lang.String.class,
1608                            com.liferay.portal.kernel.service.ServiceContext.class
1609                    };
1610            private static final Class<?>[] _searchParameterTypes38 = new Class[] {
1611                            long.class, long.class, int.class, int.class, int.class
1612                    };
1613            private static final Class<?>[] _searchParameterTypes39 = new Class[] {
1614                            long.class, long.class, long.class, java.lang.String[].class,
1615                            int.class, int.class, int.class
1616                    };
1617            private static final Class<?>[] _updateFileEntryParameterTypes40 = new Class[] {
1618                            long.class, java.lang.String.class, java.lang.String.class,
1619                            java.lang.String.class, java.lang.String.class,
1620                            java.lang.String.class, boolean.class, long.class,
1621                            java.util.Map.class, java.io.File.class, java.io.InputStream.class,
1622                            long.class, com.liferay.portal.kernel.service.ServiceContext.class
1623                    };
1624            private static final Class<?>[] _updateStatusParameterTypes41 = new Class[] {
1625                            long.class, long.class, int.class,
1626                            com.liferay.portal.kernel.service.ServiceContext.class,
1627                            java.util.Map.class
1628                    };
1629            private static final Class<?>[] _verifyFileEntryCheckOutParameterTypes42 = new Class[] {
1630                            long.class, java.lang.String.class
1631                    };
1632            private static final Class<?>[] _verifyFileEntryLockParameterTypes43 = new Class[] {
1633                            long.class, java.lang.String.class
1634                    };
1635    }