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