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.messageboards.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.messageboards.service.MBMessageServiceUtil;
027    
028    /**
029     * Provides the HTTP utility for the
030     * {@link MBMessageServiceUtil} 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 MBMessageServiceSoap
052     * @see HttpPrincipal
053     * @see MBMessageServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class MBMessageServiceHttp {
058            public static com.liferay.portlet.messageboards.model.MBMessage addDiscussionMessage(
059                    HttpPrincipal httpPrincipal, long groupId, java.lang.String className,
060                    long classPK, long threadId, long parentMessageId,
061                    java.lang.String subject, java.lang.String body,
062                    com.liferay.portal.service.ServiceContext serviceContext)
063                    throws com.liferay.portal.kernel.exception.PortalException {
064                    try {
065                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
066                                            "addDiscussionMessage", _addDiscussionMessageParameterTypes0);
067    
068                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
069                                            className, classPK, threadId, parentMessageId, subject,
070                                            body, serviceContext);
071    
072                            Object returnObj = null;
073    
074                            try {
075                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
076                            }
077                            catch (Exception e) {
078                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
079                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
080                                    }
081    
082                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
083                            }
084    
085                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
086                    }
087                    catch (com.liferay.portal.kernel.exception.SystemException se) {
088                            _log.error(se, se);
089    
090                            throw se;
091                    }
092            }
093    
094            public static com.liferay.portlet.messageboards.model.MBMessage addMessage(
095                    HttpPrincipal httpPrincipal, long groupId, long categoryId,
096                    long threadId, long parentMessageId, java.lang.String subject,
097                    java.lang.String body, java.lang.String format,
098                    java.util.List<com.liferay.portal.kernel.util.ObjectValuePair<java.lang.String, java.io.InputStream>> inputStreamOVPs,
099                    boolean anonymous, double priority, boolean allowPingbacks,
100                    com.liferay.portal.service.ServiceContext serviceContext)
101                    throws com.liferay.portal.kernel.exception.PortalException {
102                    try {
103                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
104                                            "addMessage", _addMessageParameterTypes1);
105    
106                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
107                                            categoryId, threadId, parentMessageId, subject, body,
108                                            format, inputStreamOVPs, anonymous, priority,
109                                            allowPingbacks, serviceContext);
110    
111                            Object returnObj = null;
112    
113                            try {
114                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
115                            }
116                            catch (Exception e) {
117                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
118                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
119                                    }
120    
121                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
122                            }
123    
124                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
125                    }
126                    catch (com.liferay.portal.kernel.exception.SystemException se) {
127                            _log.error(se, se);
128    
129                            throw se;
130                    }
131            }
132    
133            public static com.liferay.portlet.messageboards.model.MBMessage addMessage(
134                    HttpPrincipal httpPrincipal, long groupId, long categoryId,
135                    java.lang.String subject, java.lang.String body,
136                    java.lang.String format,
137                    java.util.List<com.liferay.portal.kernel.util.ObjectValuePair<java.lang.String, java.io.InputStream>> inputStreamOVPs,
138                    boolean anonymous, double priority, boolean allowPingbacks,
139                    com.liferay.portal.service.ServiceContext serviceContext)
140                    throws com.liferay.portal.kernel.exception.PortalException {
141                    try {
142                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
143                                            "addMessage", _addMessageParameterTypes2);
144    
145                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
146                                            categoryId, subject, body, format, inputStreamOVPs,
147                                            anonymous, priority, allowPingbacks, serviceContext);
148    
149                            Object returnObj = null;
150    
151                            try {
152                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
153                            }
154                            catch (Exception e) {
155                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
156                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
157                                    }
158    
159                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
160                            }
161    
162                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
163                    }
164                    catch (com.liferay.portal.kernel.exception.SystemException se) {
165                            _log.error(se, se);
166    
167                            throw se;
168                    }
169            }
170    
171            public static com.liferay.portlet.messageboards.model.MBMessage addMessage(
172                    HttpPrincipal httpPrincipal, long groupId, long categoryId,
173                    java.lang.String subject, java.lang.String body,
174                    java.lang.String format, java.lang.String fileName, java.io.File file,
175                    boolean anonymous, double priority, boolean allowPingbacks,
176                    com.liferay.portal.service.ServiceContext serviceContext)
177                    throws com.liferay.portal.kernel.exception.PortalException,
178                            java.io.FileNotFoundException {
179                    try {
180                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
181                                            "addMessage", _addMessageParameterTypes3);
182    
183                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
184                                            categoryId, subject, body, format, fileName, file,
185                                            anonymous, priority, allowPingbacks, serviceContext);
186    
187                            Object returnObj = null;
188    
189                            try {
190                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
191                            }
192                            catch (Exception e) {
193                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
194                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
195                                    }
196    
197                                    if (e instanceof java.io.FileNotFoundException) {
198                                            throw (java.io.FileNotFoundException)e;
199                                    }
200    
201                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
202                            }
203    
204                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
205                    }
206                    catch (com.liferay.portal.kernel.exception.SystemException se) {
207                            _log.error(se, se);
208    
209                            throw se;
210                    }
211            }
212    
213            public static com.liferay.portlet.messageboards.model.MBMessage addMessage(
214                    HttpPrincipal httpPrincipal, long categoryId, java.lang.String subject,
215                    java.lang.String body,
216                    com.liferay.portal.service.ServiceContext serviceContext)
217                    throws com.liferay.portal.kernel.exception.PortalException {
218                    try {
219                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
220                                            "addMessage", _addMessageParameterTypes4);
221    
222                            MethodHandler methodHandler = new MethodHandler(methodKey,
223                                            categoryId, subject, body, serviceContext);
224    
225                            Object returnObj = null;
226    
227                            try {
228                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
229                            }
230                            catch (Exception e) {
231                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
232                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
233                                    }
234    
235                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
236                            }
237    
238                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
239                    }
240                    catch (com.liferay.portal.kernel.exception.SystemException se) {
241                            _log.error(se, se);
242    
243                            throw se;
244                    }
245            }
246    
247            public static com.liferay.portlet.messageboards.model.MBMessage addMessage(
248                    HttpPrincipal httpPrincipal, long parentMessageId,
249                    java.lang.String subject, java.lang.String body,
250                    java.lang.String format,
251                    java.util.List<com.liferay.portal.kernel.util.ObjectValuePair<java.lang.String, java.io.InputStream>> inputStreamOVPs,
252                    boolean anonymous, double priority, boolean allowPingbacks,
253                    com.liferay.portal.service.ServiceContext serviceContext)
254                    throws com.liferay.portal.kernel.exception.PortalException {
255                    try {
256                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
257                                            "addMessage", _addMessageParameterTypes5);
258    
259                            MethodHandler methodHandler = new MethodHandler(methodKey,
260                                            parentMessageId, subject, body, format, inputStreamOVPs,
261                                            anonymous, priority, allowPingbacks, serviceContext);
262    
263                            Object returnObj = null;
264    
265                            try {
266                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
267                            }
268                            catch (Exception e) {
269                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
270                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
271                                    }
272    
273                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
274                            }
275    
276                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
277                    }
278                    catch (com.liferay.portal.kernel.exception.SystemException se) {
279                            _log.error(se, se);
280    
281                            throw se;
282                    }
283            }
284    
285            public static void addMessageAttachment(HttpPrincipal httpPrincipal,
286                    long messageId, java.lang.String fileName, java.io.File file,
287                    java.lang.String mimeType)
288                    throws com.liferay.portal.kernel.exception.PortalException {
289                    try {
290                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
291                                            "addMessageAttachment", _addMessageAttachmentParameterTypes6);
292    
293                            MethodHandler methodHandler = new MethodHandler(methodKey,
294                                            messageId, fileName, file, mimeType);
295    
296                            try {
297                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
298                            }
299                            catch (Exception e) {
300                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
301                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
302                                    }
303    
304                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
305                            }
306                    }
307                    catch (com.liferay.portal.kernel.exception.SystemException se) {
308                            _log.error(se, se);
309    
310                            throw se;
311                    }
312            }
313    
314            public static void deleteDiscussionMessage(HttpPrincipal httpPrincipal,
315                    long messageId)
316                    throws com.liferay.portal.kernel.exception.PortalException {
317                    try {
318                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
319                                            "deleteDiscussionMessage",
320                                            _deleteDiscussionMessageParameterTypes7);
321    
322                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
323    
324                            try {
325                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
326                            }
327                            catch (Exception e) {
328                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
329                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
330                                    }
331    
332                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
333                            }
334                    }
335                    catch (com.liferay.portal.kernel.exception.SystemException se) {
336                            _log.error(se, se);
337    
338                            throw se;
339                    }
340            }
341    
342            public static void deleteDiscussionMessage(HttpPrincipal httpPrincipal,
343                    long groupId, java.lang.String className, long classPK,
344                    java.lang.String permissionClassName, long permissionClassPK,
345                    long permissionOwnerId, long messageId)
346                    throws com.liferay.portal.kernel.exception.PortalException {
347                    try {
348                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
349                                            "deleteDiscussionMessage",
350                                            _deleteDiscussionMessageParameterTypes8);
351    
352                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
353                                            className, classPK, permissionClassName, permissionClassPK,
354                                            permissionOwnerId, messageId);
355    
356                            try {
357                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
358                            }
359                            catch (Exception e) {
360                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
361                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
362                                    }
363    
364                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
365                            }
366                    }
367                    catch (com.liferay.portal.kernel.exception.SystemException se) {
368                            _log.error(se, se);
369    
370                            throw se;
371                    }
372            }
373    
374            public static void deleteMessage(HttpPrincipal httpPrincipal, long messageId)
375                    throws com.liferay.portal.kernel.exception.PortalException {
376                    try {
377                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
378                                            "deleteMessage", _deleteMessageParameterTypes9);
379    
380                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
381    
382                            try {
383                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
384                            }
385                            catch (Exception e) {
386                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
387                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
388                                    }
389    
390                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
391                            }
392                    }
393                    catch (com.liferay.portal.kernel.exception.SystemException se) {
394                            _log.error(se, se);
395    
396                            throw se;
397                    }
398            }
399    
400            public static void deleteMessageAttachment(HttpPrincipal httpPrincipal,
401                    long messageId, java.lang.String fileName)
402                    throws com.liferay.portal.kernel.exception.PortalException {
403                    try {
404                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
405                                            "deleteMessageAttachment",
406                                            _deleteMessageAttachmentParameterTypes10);
407    
408                            MethodHandler methodHandler = new MethodHandler(methodKey,
409                                            messageId, fileName);
410    
411                            try {
412                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
413                            }
414                            catch (Exception e) {
415                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
416                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
417                                    }
418    
419                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
420                            }
421                    }
422                    catch (com.liferay.portal.kernel.exception.SystemException se) {
423                            _log.error(se, se);
424    
425                            throw se;
426                    }
427            }
428    
429            public static void deleteMessageAttachments(HttpPrincipal httpPrincipal,
430                    long messageId)
431                    throws com.liferay.portal.kernel.exception.PortalException {
432                    try {
433                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
434                                            "deleteMessageAttachments",
435                                            _deleteMessageAttachmentsParameterTypes11);
436    
437                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
438    
439                            try {
440                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
441                            }
442                            catch (Exception e) {
443                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
444                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
445                                    }
446    
447                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
448                            }
449                    }
450                    catch (com.liferay.portal.kernel.exception.SystemException se) {
451                            _log.error(se, se);
452    
453                            throw se;
454                    }
455            }
456    
457            public static void emptyMessageAttachments(HttpPrincipal httpPrincipal,
458                    long messageId)
459                    throws com.liferay.portal.kernel.exception.PortalException {
460                    try {
461                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
462                                            "emptyMessageAttachments",
463                                            _emptyMessageAttachmentsParameterTypes12);
464    
465                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
466    
467                            try {
468                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
469                            }
470                            catch (Exception e) {
471                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
472                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
473                                    }
474    
475                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
476                            }
477                    }
478                    catch (com.liferay.portal.kernel.exception.SystemException se) {
479                            _log.error(se, se);
480    
481                            throw se;
482                    }
483            }
484    
485            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> getCategoryMessages(
486                    HttpPrincipal httpPrincipal, long groupId, long categoryId, int status,
487                    int start, int end)
488                    throws com.liferay.portal.kernel.exception.PortalException {
489                    try {
490                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
491                                            "getCategoryMessages", _getCategoryMessagesParameterTypes13);
492    
493                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
494                                            categoryId, status, start, end);
495    
496                            Object returnObj = null;
497    
498                            try {
499                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
500                            }
501                            catch (Exception e) {
502                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
503                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
504                                    }
505    
506                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
507                            }
508    
509                            return (java.util.List<com.liferay.portlet.messageboards.model.MBMessage>)returnObj;
510                    }
511                    catch (com.liferay.portal.kernel.exception.SystemException se) {
512                            _log.error(se, se);
513    
514                            throw se;
515                    }
516            }
517    
518            public static int getCategoryMessagesCount(HttpPrincipal httpPrincipal,
519                    long groupId, long categoryId, int status) {
520                    try {
521                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
522                                            "getCategoryMessagesCount",
523                                            _getCategoryMessagesCountParameterTypes14);
524    
525                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
526                                            categoryId, status);
527    
528                            Object returnObj = null;
529    
530                            try {
531                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
532                            }
533                            catch (Exception e) {
534                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
535                            }
536    
537                            return ((Integer)returnObj).intValue();
538                    }
539                    catch (com.liferay.portal.kernel.exception.SystemException se) {
540                            _log.error(se, se);
541    
542                            throw se;
543                    }
544            }
545    
546            public static java.lang.String getCategoryMessagesRSS(
547                    HttpPrincipal httpPrincipal, long groupId, long categoryId, int status,
548                    int max, java.lang.String type, double version,
549                    java.lang.String displayStyle, java.lang.String feedURL,
550                    java.lang.String entryURL,
551                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
552                    throws com.liferay.portal.kernel.exception.PortalException {
553                    try {
554                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
555                                            "getCategoryMessagesRSS",
556                                            _getCategoryMessagesRSSParameterTypes15);
557    
558                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
559                                            categoryId, status, max, type, version, displayStyle,
560                                            feedURL, entryURL, themeDisplay);
561    
562                            Object returnObj = null;
563    
564                            try {
565                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
566                            }
567                            catch (Exception e) {
568                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
569                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
570                                    }
571    
572                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
573                            }
574    
575                            return (java.lang.String)returnObj;
576                    }
577                    catch (com.liferay.portal.kernel.exception.SystemException se) {
578                            _log.error(se, se);
579    
580                            throw se;
581                    }
582            }
583    
584            public static java.lang.String getCompanyMessagesRSS(
585                    HttpPrincipal httpPrincipal, long companyId, int status, int max,
586                    java.lang.String type, double version, java.lang.String displayStyle,
587                    java.lang.String feedURL, java.lang.String entryURL,
588                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
589                    throws com.liferay.portal.kernel.exception.PortalException {
590                    try {
591                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
592                                            "getCompanyMessagesRSS",
593                                            _getCompanyMessagesRSSParameterTypes16);
594    
595                            MethodHandler methodHandler = new MethodHandler(methodKey,
596                                            companyId, status, max, type, version, displayStyle,
597                                            feedURL, entryURL, themeDisplay);
598    
599                            Object returnObj = null;
600    
601                            try {
602                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
603                            }
604                            catch (Exception e) {
605                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
606                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
607                                    }
608    
609                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
610                            }
611    
612                            return (java.lang.String)returnObj;
613                    }
614                    catch (com.liferay.portal.kernel.exception.SystemException se) {
615                            _log.error(se, se);
616    
617                            throw se;
618                    }
619            }
620    
621            public static int getGroupMessagesCount(HttpPrincipal httpPrincipal,
622                    long groupId, int status) {
623                    try {
624                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
625                                            "getGroupMessagesCount",
626                                            _getGroupMessagesCountParameterTypes17);
627    
628                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
629                                            status);
630    
631                            Object returnObj = null;
632    
633                            try {
634                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
635                            }
636                            catch (Exception e) {
637                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
638                            }
639    
640                            return ((Integer)returnObj).intValue();
641                    }
642                    catch (com.liferay.portal.kernel.exception.SystemException se) {
643                            _log.error(se, se);
644    
645                            throw se;
646                    }
647            }
648    
649            public static java.lang.String getGroupMessagesRSS(
650                    HttpPrincipal httpPrincipal, long groupId, int status, int max,
651                    java.lang.String type, double version, java.lang.String displayStyle,
652                    java.lang.String feedURL, java.lang.String entryURL,
653                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
654                    throws com.liferay.portal.kernel.exception.PortalException {
655                    try {
656                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
657                                            "getGroupMessagesRSS", _getGroupMessagesRSSParameterTypes18);
658    
659                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
660                                            status, max, type, version, displayStyle, feedURL,
661                                            entryURL, themeDisplay);
662    
663                            Object returnObj = null;
664    
665                            try {
666                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
667                            }
668                            catch (Exception e) {
669                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
670                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
671                                    }
672    
673                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
674                            }
675    
676                            return (java.lang.String)returnObj;
677                    }
678                    catch (com.liferay.portal.kernel.exception.SystemException se) {
679                            _log.error(se, se);
680    
681                            throw se;
682                    }
683            }
684    
685            public static java.lang.String getGroupMessagesRSS(
686                    HttpPrincipal httpPrincipal, long groupId, long userId, int status,
687                    int max, java.lang.String type, double version,
688                    java.lang.String displayStyle, java.lang.String feedURL,
689                    java.lang.String entryURL,
690                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
691                    throws com.liferay.portal.kernel.exception.PortalException {
692                    try {
693                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
694                                            "getGroupMessagesRSS", _getGroupMessagesRSSParameterTypes19);
695    
696                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
697                                            userId, status, max, type, version, displayStyle, feedURL,
698                                            entryURL, themeDisplay);
699    
700                            Object returnObj = null;
701    
702                            try {
703                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
704                            }
705                            catch (Exception e) {
706                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
707                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
708                                    }
709    
710                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
711                            }
712    
713                            return (java.lang.String)returnObj;
714                    }
715                    catch (com.liferay.portal.kernel.exception.SystemException se) {
716                            _log.error(se, se);
717    
718                            throw se;
719                    }
720            }
721    
722            public static com.liferay.portlet.messageboards.model.MBMessage getMessage(
723                    HttpPrincipal httpPrincipal, long messageId)
724                    throws com.liferay.portal.kernel.exception.PortalException {
725                    try {
726                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
727                                            "getMessage", _getMessageParameterTypes20);
728    
729                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
730    
731                            Object returnObj = null;
732    
733                            try {
734                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
735                            }
736                            catch (Exception e) {
737                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
738                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
739                                    }
740    
741                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
742                            }
743    
744                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
745                    }
746                    catch (com.liferay.portal.kernel.exception.SystemException se) {
747                            _log.error(se, se);
748    
749                            throw se;
750                    }
751            }
752    
753            public static com.liferay.portlet.messageboards.model.MBMessageDisplay getMessageDisplay(
754                    HttpPrincipal httpPrincipal, long messageId, int status,
755                    boolean includePrevAndNext)
756                    throws com.liferay.portal.kernel.exception.PortalException {
757                    try {
758                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
759                                            "getMessageDisplay", _getMessageDisplayParameterTypes21);
760    
761                            MethodHandler methodHandler = new MethodHandler(methodKey,
762                                            messageId, status, includePrevAndNext);
763    
764                            Object returnObj = null;
765    
766                            try {
767                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
768                            }
769                            catch (Exception e) {
770                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
771                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
772                                    }
773    
774                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
775                            }
776    
777                            return (com.liferay.portlet.messageboards.model.MBMessageDisplay)returnObj;
778                    }
779                    catch (com.liferay.portal.kernel.exception.SystemException se) {
780                            _log.error(se, se);
781    
782                            throw se;
783                    }
784            }
785    
786            public static com.liferay.portlet.messageboards.model.MBMessageDisplay getMessageDisplay(
787                    HttpPrincipal httpPrincipal, long messageId, int status,
788                    java.lang.String threadView, boolean includePrevAndNext)
789                    throws com.liferay.portal.kernel.exception.PortalException {
790                    try {
791                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
792                                            "getMessageDisplay", _getMessageDisplayParameterTypes22);
793    
794                            MethodHandler methodHandler = new MethodHandler(methodKey,
795                                            messageId, status, threadView, includePrevAndNext);
796    
797                            Object returnObj = null;
798    
799                            try {
800                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
801                            }
802                            catch (Exception e) {
803                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
804                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
805                                    }
806    
807                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
808                            }
809    
810                            return (com.liferay.portlet.messageboards.model.MBMessageDisplay)returnObj;
811                    }
812                    catch (com.liferay.portal.kernel.exception.SystemException se) {
813                            _log.error(se, se);
814    
815                            throw se;
816                    }
817            }
818    
819            public static int getThreadAnswersCount(HttpPrincipal httpPrincipal,
820                    long groupId, long categoryId, long threadId) {
821                    try {
822                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
823                                            "getThreadAnswersCount",
824                                            _getThreadAnswersCountParameterTypes23);
825    
826                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
827                                            categoryId, threadId);
828    
829                            Object returnObj = null;
830    
831                            try {
832                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
833                            }
834                            catch (Exception e) {
835                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
836                            }
837    
838                            return ((Integer)returnObj).intValue();
839                    }
840                    catch (com.liferay.portal.kernel.exception.SystemException se) {
841                            _log.error(se, se);
842    
843                            throw se;
844                    }
845            }
846    
847            public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> getThreadMessages(
848                    HttpPrincipal httpPrincipal, long groupId, long categoryId,
849                    long threadId, int status, int start, int end) {
850                    try {
851                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
852                                            "getThreadMessages", _getThreadMessagesParameterTypes24);
853    
854                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
855                                            categoryId, threadId, status, start, end);
856    
857                            Object returnObj = null;
858    
859                            try {
860                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
861                            }
862                            catch (Exception e) {
863                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
864                            }
865    
866                            return (java.util.List<com.liferay.portlet.messageboards.model.MBMessage>)returnObj;
867                    }
868                    catch (com.liferay.portal.kernel.exception.SystemException se) {
869                            _log.error(se, se);
870    
871                            throw se;
872                    }
873            }
874    
875            public static int getThreadMessagesCount(HttpPrincipal httpPrincipal,
876                    long groupId, long categoryId, long threadId, int status) {
877                    try {
878                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
879                                            "getThreadMessagesCount",
880                                            _getThreadMessagesCountParameterTypes25);
881    
882                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
883                                            categoryId, threadId, status);
884    
885                            Object returnObj = null;
886    
887                            try {
888                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
889                            }
890                            catch (Exception e) {
891                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
892                            }
893    
894                            return ((Integer)returnObj).intValue();
895                    }
896                    catch (com.liferay.portal.kernel.exception.SystemException se) {
897                            _log.error(se, se);
898    
899                            throw se;
900                    }
901            }
902    
903            public static java.lang.String getThreadMessagesRSS(
904                    HttpPrincipal httpPrincipal, long threadId, int status, int max,
905                    java.lang.String type, double version, java.lang.String displayStyle,
906                    java.lang.String feedURL, java.lang.String entryURL,
907                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
908                    throws com.liferay.portal.kernel.exception.PortalException {
909                    try {
910                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
911                                            "getThreadMessagesRSS",
912                                            _getThreadMessagesRSSParameterTypes26);
913    
914                            MethodHandler methodHandler = new MethodHandler(methodKey,
915                                            threadId, status, max, type, version, displayStyle,
916                                            feedURL, entryURL, themeDisplay);
917    
918                            Object returnObj = null;
919    
920                            try {
921                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
922                            }
923                            catch (Exception e) {
924                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
925                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
926                                    }
927    
928                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
929                            }
930    
931                            return (java.lang.String)returnObj;
932                    }
933                    catch (com.liferay.portal.kernel.exception.SystemException se) {
934                            _log.error(se, se);
935    
936                            throw se;
937                    }
938            }
939    
940            public static void restoreMessageAttachmentFromTrash(
941                    HttpPrincipal httpPrincipal, long messageId, java.lang.String fileName)
942                    throws com.liferay.portal.kernel.exception.PortalException {
943                    try {
944                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
945                                            "restoreMessageAttachmentFromTrash",
946                                            _restoreMessageAttachmentFromTrashParameterTypes27);
947    
948                            MethodHandler methodHandler = new MethodHandler(methodKey,
949                                            messageId, fileName);
950    
951                            try {
952                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
953                            }
954                            catch (Exception e) {
955                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
956                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
957                                    }
958    
959                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
960                            }
961                    }
962                    catch (com.liferay.portal.kernel.exception.SystemException se) {
963                            _log.error(se, se);
964    
965                            throw se;
966                    }
967            }
968    
969            public static void subscribeMessage(HttpPrincipal httpPrincipal,
970                    long messageId)
971                    throws com.liferay.portal.kernel.exception.PortalException {
972                    try {
973                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
974                                            "subscribeMessage", _subscribeMessageParameterTypes28);
975    
976                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
977    
978                            try {
979                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
980                            }
981                            catch (Exception e) {
982                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
983                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
984                                    }
985    
986                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
987                            }
988                    }
989                    catch (com.liferay.portal.kernel.exception.SystemException se) {
990                            _log.error(se, se);
991    
992                            throw se;
993                    }
994            }
995    
996            public static void unsubscribeMessage(HttpPrincipal httpPrincipal,
997                    long messageId)
998                    throws com.liferay.portal.kernel.exception.PortalException {
999                    try {
1000                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
1001                                            "unsubscribeMessage", _unsubscribeMessageParameterTypes29);
1002    
1003                            MethodHandler methodHandler = new MethodHandler(methodKey, messageId);
1004    
1005                            try {
1006                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1007                            }
1008                            catch (Exception e) {
1009                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1010                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1011                                    }
1012    
1013                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1014                            }
1015                    }
1016                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1017                            _log.error(se, se);
1018    
1019                            throw se;
1020                    }
1021            }
1022    
1023            public static void updateAnswer(HttpPrincipal httpPrincipal,
1024                    long messageId, boolean answer, boolean cascade)
1025                    throws com.liferay.portal.kernel.exception.PortalException {
1026                    try {
1027                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
1028                                            "updateAnswer", _updateAnswerParameterTypes30);
1029    
1030                            MethodHandler methodHandler = new MethodHandler(methodKey,
1031                                            messageId, answer, cascade);
1032    
1033                            try {
1034                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1035                            }
1036                            catch (Exception e) {
1037                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1038                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1039                                    }
1040    
1041                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1042                            }
1043                    }
1044                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1045                            _log.error(se, se);
1046    
1047                            throw se;
1048                    }
1049            }
1050    
1051            public static com.liferay.portlet.messageboards.model.MBMessage updateDiscussionMessage(
1052                    HttpPrincipal httpPrincipal, java.lang.String className, long classPK,
1053                    long messageId, java.lang.String subject, java.lang.String body,
1054                    com.liferay.portal.service.ServiceContext serviceContext)
1055                    throws com.liferay.portal.kernel.exception.PortalException {
1056                    try {
1057                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
1058                                            "updateDiscussionMessage",
1059                                            _updateDiscussionMessageParameterTypes31);
1060    
1061                            MethodHandler methodHandler = new MethodHandler(methodKey,
1062                                            className, classPK, messageId, subject, body, serviceContext);
1063    
1064                            Object returnObj = null;
1065    
1066                            try {
1067                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1068                            }
1069                            catch (Exception e) {
1070                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1071                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1072                                    }
1073    
1074                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1075                            }
1076    
1077                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
1078                    }
1079                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1080                            _log.error(se, se);
1081    
1082                            throw se;
1083                    }
1084            }
1085    
1086            public static com.liferay.portlet.messageboards.model.MBMessage updateMessage(
1087                    HttpPrincipal httpPrincipal, long messageId, java.lang.String subject,
1088                    java.lang.String body,
1089                    java.util.List<com.liferay.portal.kernel.util.ObjectValuePair<java.lang.String, java.io.InputStream>> inputStreamOVPs,
1090                    java.util.List<java.lang.String> existingFiles, double priority,
1091                    boolean allowPingbacks,
1092                    com.liferay.portal.service.ServiceContext serviceContext)
1093                    throws com.liferay.portal.kernel.exception.PortalException {
1094                    try {
1095                            MethodKey methodKey = new MethodKey(MBMessageServiceUtil.class,
1096                                            "updateMessage", _updateMessageParameterTypes32);
1097    
1098                            MethodHandler methodHandler = new MethodHandler(methodKey,
1099                                            messageId, subject, body, inputStreamOVPs, existingFiles,
1100                                            priority, allowPingbacks, serviceContext);
1101    
1102                            Object returnObj = null;
1103    
1104                            try {
1105                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1106                            }
1107                            catch (Exception e) {
1108                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1109                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1110                                    }
1111    
1112                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1113                            }
1114    
1115                            return (com.liferay.portlet.messageboards.model.MBMessage)returnObj;
1116                    }
1117                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1118                            _log.error(se, se);
1119    
1120                            throw se;
1121                    }
1122            }
1123    
1124            private static Log _log = LogFactoryUtil.getLog(MBMessageServiceHttp.class);
1125            private static final Class<?>[] _addDiscussionMessageParameterTypes0 = new Class[] {
1126                            long.class, java.lang.String.class, long.class, long.class,
1127                            long.class, java.lang.String.class, java.lang.String.class,
1128                            com.liferay.portal.service.ServiceContext.class
1129                    };
1130            private static final Class<?>[] _addMessageParameterTypes1 = new Class[] {
1131                            long.class, long.class, long.class, long.class,
1132                            java.lang.String.class, java.lang.String.class,
1133                            java.lang.String.class, java.util.List.class, boolean.class,
1134                            double.class, boolean.class,
1135                            com.liferay.portal.service.ServiceContext.class
1136                    };
1137            private static final Class<?>[] _addMessageParameterTypes2 = new Class[] {
1138                            long.class, long.class, java.lang.String.class,
1139                            java.lang.String.class, java.lang.String.class, java.util.List.class,
1140                            boolean.class, double.class, boolean.class,
1141                            com.liferay.portal.service.ServiceContext.class
1142                    };
1143            private static final Class<?>[] _addMessageParameterTypes3 = new Class[] {
1144                            long.class, long.class, java.lang.String.class,
1145                            java.lang.String.class, java.lang.String.class,
1146                            java.lang.String.class, java.io.File.class, boolean.class,
1147                            double.class, boolean.class,
1148                            com.liferay.portal.service.ServiceContext.class
1149                    };
1150            private static final Class<?>[] _addMessageParameterTypes4 = new Class[] {
1151                            long.class, java.lang.String.class, java.lang.String.class,
1152                            com.liferay.portal.service.ServiceContext.class
1153                    };
1154            private static final Class<?>[] _addMessageParameterTypes5 = new Class[] {
1155                            long.class, java.lang.String.class, java.lang.String.class,
1156                            java.lang.String.class, java.util.List.class, boolean.class,
1157                            double.class, boolean.class,
1158                            com.liferay.portal.service.ServiceContext.class
1159                    };
1160            private static final Class<?>[] _addMessageAttachmentParameterTypes6 = new Class[] {
1161                            long.class, java.lang.String.class, java.io.File.class,
1162                            java.lang.String.class
1163                    };
1164            private static final Class<?>[] _deleteDiscussionMessageParameterTypes7 = new Class[] {
1165                            long.class
1166                    };
1167            private static final Class<?>[] _deleteDiscussionMessageParameterTypes8 = new Class[] {
1168                            long.class, java.lang.String.class, long.class,
1169                            java.lang.String.class, long.class, long.class, long.class
1170                    };
1171            private static final Class<?>[] _deleteMessageParameterTypes9 = new Class[] {
1172                            long.class
1173                    };
1174            private static final Class<?>[] _deleteMessageAttachmentParameterTypes10 = new Class[] {
1175                            long.class, java.lang.String.class
1176                    };
1177            private static final Class<?>[] _deleteMessageAttachmentsParameterTypes11 = new Class[] {
1178                            long.class
1179                    };
1180            private static final Class<?>[] _emptyMessageAttachmentsParameterTypes12 = new Class[] {
1181                            long.class
1182                    };
1183            private static final Class<?>[] _getCategoryMessagesParameterTypes13 = new Class[] {
1184                            long.class, long.class, int.class, int.class, int.class
1185                    };
1186            private static final Class<?>[] _getCategoryMessagesCountParameterTypes14 = new Class[] {
1187                            long.class, long.class, int.class
1188                    };
1189            private static final Class<?>[] _getCategoryMessagesRSSParameterTypes15 = new Class[] {
1190                            long.class, long.class, int.class, int.class, java.lang.String.class,
1191                            double.class, java.lang.String.class, java.lang.String.class,
1192                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
1193                    };
1194            private static final Class<?>[] _getCompanyMessagesRSSParameterTypes16 = new Class[] {
1195                            long.class, int.class, int.class, java.lang.String.class,
1196                            double.class, java.lang.String.class, java.lang.String.class,
1197                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
1198                    };
1199            private static final Class<?>[] _getGroupMessagesCountParameterTypes17 = new Class[] {
1200                            long.class, int.class
1201                    };
1202            private static final Class<?>[] _getGroupMessagesRSSParameterTypes18 = new Class[] {
1203                            long.class, int.class, int.class, java.lang.String.class,
1204                            double.class, java.lang.String.class, java.lang.String.class,
1205                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
1206                    };
1207            private static final Class<?>[] _getGroupMessagesRSSParameterTypes19 = new Class[] {
1208                            long.class, long.class, int.class, int.class, java.lang.String.class,
1209                            double.class, java.lang.String.class, java.lang.String.class,
1210                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
1211                    };
1212            private static final Class<?>[] _getMessageParameterTypes20 = new Class[] {
1213                            long.class
1214                    };
1215            private static final Class<?>[] _getMessageDisplayParameterTypes21 = new Class[] {
1216                            long.class, int.class, boolean.class
1217                    };
1218            private static final Class<?>[] _getMessageDisplayParameterTypes22 = new Class[] {
1219                            long.class, int.class, java.lang.String.class, boolean.class
1220                    };
1221            private static final Class<?>[] _getThreadAnswersCountParameterTypes23 = new Class[] {
1222                            long.class, long.class, long.class
1223                    };
1224            private static final Class<?>[] _getThreadMessagesParameterTypes24 = new Class[] {
1225                            long.class, long.class, long.class, int.class, int.class, int.class
1226                    };
1227            private static final Class<?>[] _getThreadMessagesCountParameterTypes25 = new Class[] {
1228                            long.class, long.class, long.class, int.class
1229                    };
1230            private static final Class<?>[] _getThreadMessagesRSSParameterTypes26 = new Class[] {
1231                            long.class, int.class, int.class, java.lang.String.class,
1232                            double.class, java.lang.String.class, java.lang.String.class,
1233                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
1234                    };
1235            private static final Class<?>[] _restoreMessageAttachmentFromTrashParameterTypes27 =
1236                    new Class[] { long.class, java.lang.String.class };
1237            private static final Class<?>[] _subscribeMessageParameterTypes28 = new Class[] {
1238                            long.class
1239                    };
1240            private static final Class<?>[] _unsubscribeMessageParameterTypes29 = new Class[] {
1241                            long.class
1242                    };
1243            private static final Class<?>[] _updateAnswerParameterTypes30 = new Class[] {
1244                            long.class, boolean.class, boolean.class
1245                    };
1246            private static final Class<?>[] _updateDiscussionMessageParameterTypes31 = new Class[] {
1247                            java.lang.String.class, long.class, long.class,
1248                            java.lang.String.class, java.lang.String.class,
1249                            com.liferay.portal.service.ServiceContext.class
1250                    };
1251            private static final Class<?>[] _updateMessageParameterTypes32 = new Class[] {
1252                            long.class, java.lang.String.class, java.lang.String.class,
1253                            java.util.List.class, java.util.List.class, double.class,
1254                            boolean.class, com.liferay.portal.service.ServiceContext.class
1255                    };
1256    }