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 DLFileEntryServiceUtil} service utility. The
031     * static methods of this class calls the same methods of the service utility.
032     * However, the signatures are different because it requires an additional
033     * {@link HttpPrincipal} parameter.
034     *
035     * <p>
036     * The benefits of using the HTTP utility is that it is fast and allows for
037     * tunneling without the cost of serializing to text. The drawback is that it
038     * only works with Java.
039     * </p>
040     *
041     * <p>
042     * Set the property <b>tunnel.servlet.hosts.allowed</b> in portal.properties to
043     * configure security.
044     * </p>
045     *
046     * <p>
047     * The HTTP utility is only generated for remote services.
048     * </p>
049     *
050     * @author Brian Wing Shun Chan
051     * @see DLFileEntryServiceSoap
052     * @see HttpPrincipal
053     * @see DLFileEntryServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class DLFileEntryServiceHttp {
058            public static com.liferay.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.DDMFormValues> ddmFormValuesMap,
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, ddmFormValuesMap,
075                                            file, is, size, serviceContext);
076    
077                            Object returnObj = null;
078    
079                            try {
080                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
081                            }
082                            catch (Exception e) {
083                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
084                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
085                                    }
086    
087                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
088                            }
089    
090                            return (com.liferay.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.kernel.lock.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.kernel.lock.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 boolean isKeepFileVersionLabel(HttpPrincipal httpPrincipal,
1233                    long fileEntryId,
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                                            "isKeepFileVersionLabel",
1239                                            _isKeepFileVersionLabelParameterTypes37);
1240    
1241                            MethodHandler methodHandler = new MethodHandler(methodKey,
1242                                            fileEntryId, serviceContext);
1243    
1244                            Object returnObj = null;
1245    
1246                            try {
1247                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1248                            }
1249                            catch (Exception e) {
1250                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1251                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1252                                    }
1253    
1254                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1255                            }
1256    
1257                            return ((Boolean)returnObj).booleanValue();
1258                    }
1259                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1260                            _log.error(se, se);
1261    
1262                            throw se;
1263                    }
1264            }
1265    
1266            public static com.liferay.portlet.documentlibrary.model.DLFileEntry moveFileEntry(
1267                    HttpPrincipal httpPrincipal, long fileEntryId, long newFolderId,
1268                    com.liferay.portal.service.ServiceContext serviceContext)
1269                    throws com.liferay.portal.kernel.exception.PortalException {
1270                    try {
1271                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1272                                            "moveFileEntry", _moveFileEntryParameterTypes38);
1273    
1274                            MethodHandler methodHandler = new MethodHandler(methodKey,
1275                                            fileEntryId, newFolderId, serviceContext);
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.portlet.documentlibrary.model.DLFileEntry)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 com.liferay.portal.kernel.lock.Lock refreshFileEntryLock(
1300                    HttpPrincipal httpPrincipal, java.lang.String lockUuid, long companyId,
1301                    long expirationTime)
1302                    throws com.liferay.portal.kernel.exception.PortalException {
1303                    try {
1304                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1305                                            "refreshFileEntryLock",
1306                                            _refreshFileEntryLockParameterTypes39);
1307    
1308                            MethodHandler methodHandler = new MethodHandler(methodKey,
1309                                            lockUuid, companyId, expirationTime);
1310    
1311                            Object returnObj = null;
1312    
1313                            try {
1314                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1315                            }
1316                            catch (Exception e) {
1317                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1318                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1319                                    }
1320    
1321                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1322                            }
1323    
1324                            return (com.liferay.portal.kernel.lock.Lock)returnObj;
1325                    }
1326                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1327                            _log.error(se, se);
1328    
1329                            throw se;
1330                    }
1331            }
1332    
1333            public static void revertFileEntry(HttpPrincipal httpPrincipal,
1334                    long fileEntryId, java.lang.String version,
1335                    com.liferay.portal.service.ServiceContext serviceContext)
1336                    throws com.liferay.portal.kernel.exception.PortalException {
1337                    try {
1338                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1339                                            "revertFileEntry", _revertFileEntryParameterTypes40);
1340    
1341                            MethodHandler methodHandler = new MethodHandler(methodKey,
1342                                            fileEntryId, version, serviceContext);
1343    
1344                            try {
1345                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1346                            }
1347                            catch (Exception e) {
1348                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1349                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1350                                    }
1351    
1352                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1353                            }
1354                    }
1355                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1356                            _log.error(se, se);
1357    
1358                            throw se;
1359                    }
1360            }
1361    
1362            public static com.liferay.portal.kernel.search.Hits search(
1363                    HttpPrincipal httpPrincipal, long groupId, long creatorUserId,
1364                    int status, int start, int end)
1365                    throws com.liferay.portal.kernel.exception.PortalException {
1366                    try {
1367                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1368                                            "search", _searchParameterTypes41);
1369    
1370                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1371                                            creatorUserId, status, start, end);
1372    
1373                            Object returnObj = null;
1374    
1375                            try {
1376                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1377                            }
1378                            catch (Exception e) {
1379                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1380                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1381                                    }
1382    
1383                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1384                            }
1385    
1386                            return (com.liferay.portal.kernel.search.Hits)returnObj;
1387                    }
1388                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1389                            _log.error(se, se);
1390    
1391                            throw se;
1392                    }
1393            }
1394    
1395            public static com.liferay.portal.kernel.search.Hits search(
1396                    HttpPrincipal httpPrincipal, long groupId, long creatorUserId,
1397                    long folderId, java.lang.String[] mimeTypes, int status, int start,
1398                    int end) throws com.liferay.portal.kernel.exception.PortalException {
1399                    try {
1400                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1401                                            "search", _searchParameterTypes42);
1402    
1403                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1404                                            creatorUserId, folderId, mimeTypes, status, start, end);
1405    
1406                            Object returnObj = null;
1407    
1408                            try {
1409                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1410                            }
1411                            catch (Exception e) {
1412                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1413                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1414                                    }
1415    
1416                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1417                            }
1418    
1419                            return (com.liferay.portal.kernel.search.Hits)returnObj;
1420                    }
1421                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1422                            _log.error(se, se);
1423    
1424                            throw se;
1425                    }
1426            }
1427    
1428            public static com.liferay.portlet.documentlibrary.model.DLFileEntry updateFileEntry(
1429                    HttpPrincipal httpPrincipal, long fileEntryId,
1430                    java.lang.String sourceFileName, java.lang.String mimeType,
1431                    java.lang.String title, java.lang.String description,
1432                    java.lang.String changeLog, boolean majorVersion, long fileEntryTypeId,
1433                    java.util.Map<java.lang.String, com.liferay.portlet.dynamicdatamapping.DDMFormValues> ddmFormValuesMap,
1434                    java.io.File file, java.io.InputStream is, long size,
1435                    com.liferay.portal.service.ServiceContext serviceContext)
1436                    throws com.liferay.portal.kernel.exception.PortalException {
1437                    try {
1438                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1439                                            "updateFileEntry", _updateFileEntryParameterTypes43);
1440    
1441                            MethodHandler methodHandler = new MethodHandler(methodKey,
1442                                            fileEntryId, sourceFileName, mimeType, title, description,
1443                                            changeLog, majorVersion, fileEntryTypeId, ddmFormValuesMap,
1444                                            file, is, size, serviceContext);
1445    
1446                            Object returnObj = null;
1447    
1448                            try {
1449                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1450                            }
1451                            catch (Exception e) {
1452                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1453                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1454                                    }
1455    
1456                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1457                            }
1458    
1459                            return (com.liferay.portlet.documentlibrary.model.DLFileEntry)returnObj;
1460                    }
1461                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1462                            _log.error(se, se);
1463    
1464                            throw se;
1465                    }
1466            }
1467    
1468            public static com.liferay.portlet.documentlibrary.model.DLFileEntry updateStatus(
1469                    HttpPrincipal httpPrincipal, long userId, long fileVersionId,
1470                    int status, com.liferay.portal.service.ServiceContext serviceContext,
1471                    java.util.Map<java.lang.String, java.io.Serializable> workflowContext)
1472                    throws com.liferay.portal.kernel.exception.PortalException {
1473                    try {
1474                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1475                                            "updateStatus", _updateStatusParameterTypes44);
1476    
1477                            MethodHandler methodHandler = new MethodHandler(methodKey, userId,
1478                                            fileVersionId, status, serviceContext, workflowContext);
1479    
1480                            Object returnObj = null;
1481    
1482                            try {
1483                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1484                            }
1485                            catch (Exception e) {
1486                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1487                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1488                                    }
1489    
1490                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1491                            }
1492    
1493                            return (com.liferay.portlet.documentlibrary.model.DLFileEntry)returnObj;
1494                    }
1495                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1496                            _log.error(se, se);
1497    
1498                            throw se;
1499                    }
1500            }
1501    
1502            public static boolean verifyFileEntryCheckOut(HttpPrincipal httpPrincipal,
1503                    long fileEntryId, java.lang.String lockUuid)
1504                    throws com.liferay.portal.kernel.exception.PortalException {
1505                    try {
1506                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1507                                            "verifyFileEntryCheckOut",
1508                                            _verifyFileEntryCheckOutParameterTypes45);
1509    
1510                            MethodHandler methodHandler = new MethodHandler(methodKey,
1511                                            fileEntryId, lockUuid);
1512    
1513                            Object returnObj = null;
1514    
1515                            try {
1516                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1517                            }
1518                            catch (Exception e) {
1519                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1520                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1521                                    }
1522    
1523                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1524                            }
1525    
1526                            return ((Boolean)returnObj).booleanValue();
1527                    }
1528                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1529                            _log.error(se, se);
1530    
1531                            throw se;
1532                    }
1533            }
1534    
1535            public static boolean verifyFileEntryLock(HttpPrincipal httpPrincipal,
1536                    long fileEntryId, java.lang.String lockUuid)
1537                    throws com.liferay.portal.kernel.exception.PortalException {
1538                    try {
1539                            MethodKey methodKey = new MethodKey(DLFileEntryServiceUtil.class,
1540                                            "verifyFileEntryLock", _verifyFileEntryLockParameterTypes46);
1541    
1542                            MethodHandler methodHandler = new MethodHandler(methodKey,
1543                                            fileEntryId, lockUuid);
1544    
1545                            Object returnObj = null;
1546    
1547                            try {
1548                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1549                            }
1550                            catch (Exception e) {
1551                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1552                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1553                                    }
1554    
1555                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1556                            }
1557    
1558                            return ((Boolean)returnObj).booleanValue();
1559                    }
1560                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1561                            _log.error(se, se);
1562    
1563                            throw se;
1564                    }
1565            }
1566    
1567            private static Log _log = LogFactoryUtil.getLog(DLFileEntryServiceHttp.class);
1568            private static final Class<?>[] _addFileEntryParameterTypes0 = new Class[] {
1569                            long.class, long.class, long.class, java.lang.String.class,
1570                            java.lang.String.class, java.lang.String.class,
1571                            java.lang.String.class, java.lang.String.class, long.class,
1572                            java.util.Map.class, java.io.File.class, java.io.InputStream.class,
1573                            long.class, com.liferay.portal.service.ServiceContext.class
1574                    };
1575            private static final Class<?>[] _cancelCheckOutParameterTypes1 = new Class[] {
1576                            long.class
1577                    };
1578            private static final Class<?>[] _checkInFileEntryParameterTypes2 = new Class[] {
1579                            long.class, boolean.class, java.lang.String.class,
1580                            com.liferay.portal.service.ServiceContext.class
1581                    };
1582            private static final Class<?>[] _checkInFileEntryParameterTypes3 = new Class[] {
1583                            long.class, java.lang.String.class
1584                    };
1585            private static final Class<?>[] _checkInFileEntryParameterTypes4 = new Class[] {
1586                            long.class, java.lang.String.class,
1587                            com.liferay.portal.service.ServiceContext.class
1588                    };
1589            private static final Class<?>[] _checkOutFileEntryParameterTypes5 = new Class[] {
1590                            long.class
1591                    };
1592            private static final Class<?>[] _checkOutFileEntryParameterTypes6 = new Class[] {
1593                            long.class, com.liferay.portal.service.ServiceContext.class
1594                    };
1595            private static final Class<?>[] _checkOutFileEntryParameterTypes7 = new Class[] {
1596                            long.class, java.lang.String.class, long.class
1597                    };
1598            private static final Class<?>[] _checkOutFileEntryParameterTypes8 = new Class[] {
1599                            long.class, java.lang.String.class, long.class,
1600                            com.liferay.portal.service.ServiceContext.class
1601                    };
1602            private static final Class<?>[] _copyFileEntryParameterTypes9 = new Class[] {
1603                            long.class, long.class, long.class, long.class,
1604                            com.liferay.portal.service.ServiceContext.class
1605                    };
1606            private static final Class<?>[] _deleteFileEntryParameterTypes10 = new Class[] {
1607                            long.class
1608                    };
1609            private static final Class<?>[] _deleteFileEntryParameterTypes11 = new Class[] {
1610                            long.class, long.class, java.lang.String.class
1611                    };
1612            private static final Class<?>[] _deleteFileVersionParameterTypes12 = new Class[] {
1613                            long.class, java.lang.String.class
1614                    };
1615            private static final Class<?>[] _fetchFileEntryByImageIdParameterTypes13 = new Class[] {
1616                            long.class
1617                    };
1618            private static final Class<?>[] _getFileAsStreamParameterTypes14 = new Class[] {
1619                            long.class, java.lang.String.class
1620                    };
1621            private static final Class<?>[] _getFileAsStreamParameterTypes15 = new Class[] {
1622                            long.class, java.lang.String.class, boolean.class
1623                    };
1624            private static final Class<?>[] _getFileEntriesParameterTypes16 = new Class[] {
1625                            long.class, long.class, int.class, int.class, int.class,
1626                            com.liferay.portal.kernel.util.OrderByComparator.class
1627                    };
1628            private static final Class<?>[] _getFileEntriesParameterTypes17 = new Class[] {
1629                            long.class, long.class, int.class, int.class,
1630                            com.liferay.portal.kernel.util.OrderByComparator.class
1631                    };
1632            private static final Class<?>[] _getFileEntriesParameterTypes18 = new Class[] {
1633                            long.class, long.class, long.class, int.class, int.class,
1634                            com.liferay.portal.kernel.util.OrderByComparator.class
1635                    };
1636            private static final Class<?>[] _getFileEntriesParameterTypes19 = new Class[] {
1637                            long.class, long.class, java.lang.String[].class, int.class,
1638                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
1639                    };
1640            private static final Class<?>[] _getFileEntriesCountParameterTypes20 = new Class[] {
1641                            long.class, long.class
1642                    };
1643            private static final Class<?>[] _getFileEntriesCountParameterTypes21 = new Class[] {
1644                            long.class, long.class, int.class
1645                    };
1646            private static final Class<?>[] _getFileEntriesCountParameterTypes22 = new Class[] {
1647                            long.class, long.class, long.class
1648                    };
1649            private static final Class<?>[] _getFileEntriesCountParameterTypes23 = new Class[] {
1650                            long.class, long.class, java.lang.String[].class
1651                    };
1652            private static final Class<?>[] _getFileEntryParameterTypes24 = new Class[] {
1653                            long.class
1654                    };
1655            private static final Class<?>[] _getFileEntryParameterTypes25 = new Class[] {
1656                            long.class, long.class, java.lang.String.class
1657                    };
1658            private static final Class<?>[] _getFileEntryByUuidAndGroupIdParameterTypes26 =
1659                    new Class[] { java.lang.String.class, long.class };
1660            private static final Class<?>[] _getFileEntryLockParameterTypes27 = new Class[] {
1661                            long.class
1662                    };
1663            private static final Class<?>[] _getFoldersFileEntriesCountParameterTypes28 = new Class[] {
1664                            long.class, java.util.List.class, int.class
1665                    };
1666            private static final Class<?>[] _getGroupFileEntriesParameterTypes29 = new Class[] {
1667                            long.class, long.class, long.class, int.class, int.class,
1668                            com.liferay.portal.kernel.util.OrderByComparator.class
1669                    };
1670            private static final Class<?>[] _getGroupFileEntriesParameterTypes30 = new Class[] {
1671                            long.class, long.class, long.class, long.class,
1672                            java.lang.String[].class, int.class, int.class, int.class,
1673                            com.liferay.portal.kernel.util.OrderByComparator.class
1674                    };
1675            private static final Class<?>[] _getGroupFileEntriesParameterTypes31 = new Class[] {
1676                            long.class, long.class, long.class, java.lang.String[].class,
1677                            int.class, int.class, int.class,
1678                            com.liferay.portal.kernel.util.OrderByComparator.class
1679                    };
1680            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes32 = new Class[] {
1681                            long.class, long.class, long.class
1682                    };
1683            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes33 = new Class[] {
1684                            long.class, long.class, long.class, long.class,
1685                            java.lang.String[].class, int.class
1686                    };
1687            private static final Class<?>[] _getGroupFileEntriesCountParameterTypes34 = new Class[] {
1688                            long.class, long.class, long.class, java.lang.String[].class,
1689                            int.class
1690                    };
1691            private static final Class<?>[] _hasFileEntryLockParameterTypes35 = new Class[] {
1692                            long.class
1693                    };
1694            private static final Class<?>[] _isFileEntryCheckedOutParameterTypes36 = new Class[] {
1695                            long.class
1696                    };
1697            private static final Class<?>[] _isKeepFileVersionLabelParameterTypes37 = new Class[] {
1698                            long.class, com.liferay.portal.service.ServiceContext.class
1699                    };
1700            private static final Class<?>[] _moveFileEntryParameterTypes38 = new Class[] {
1701                            long.class, long.class,
1702                            com.liferay.portal.service.ServiceContext.class
1703                    };
1704            private static final Class<?>[] _refreshFileEntryLockParameterTypes39 = new Class[] {
1705                            java.lang.String.class, long.class, long.class
1706                    };
1707            private static final Class<?>[] _revertFileEntryParameterTypes40 = new Class[] {
1708                            long.class, java.lang.String.class,
1709                            com.liferay.portal.service.ServiceContext.class
1710                    };
1711            private static final Class<?>[] _searchParameterTypes41 = new Class[] {
1712                            long.class, long.class, int.class, int.class, int.class
1713                    };
1714            private static final Class<?>[] _searchParameterTypes42 = new Class[] {
1715                            long.class, long.class, long.class, java.lang.String[].class,
1716                            int.class, int.class, int.class
1717                    };
1718            private static final Class<?>[] _updateFileEntryParameterTypes43 = new Class[] {
1719                            long.class, java.lang.String.class, java.lang.String.class,
1720                            java.lang.String.class, java.lang.String.class,
1721                            java.lang.String.class, boolean.class, long.class,
1722                            java.util.Map.class, java.io.File.class, java.io.InputStream.class,
1723                            long.class, com.liferay.portal.service.ServiceContext.class
1724                    };
1725            private static final Class<?>[] _updateStatusParameterTypes44 = new Class[] {
1726                            long.class, long.class, int.class,
1727                            com.liferay.portal.service.ServiceContext.class, java.util.Map.class
1728                    };
1729            private static final Class<?>[] _verifyFileEntryCheckOutParameterTypes45 = new Class[] {
1730                            long.class, java.lang.String.class
1731                    };
1732            private static final Class<?>[] _verifyFileEntryLockParameterTypes46 = new Class[] {
1733                            long.class, java.lang.String.class
1734                    };
1735    }