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.journal.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.journal.service.JournalArticleServiceUtil;
027    
028    /**
029     * Provides the HTTP utility for the
030     * {@link com.liferay.portlet.journal.service.JournalArticleServiceUtil} service utility. The
031     * static methods of this class calls the same methods of the service utility.
032     * However, the signatures are different because it requires an additional
033     * {@link com.liferay.portal.security.auth.HttpPrincipal} parameter.
034     *
035     * <p>
036     * The benefits of using the HTTP utility is that it is fast and allows for
037     * tunneling without the cost of serializing to text. The drawback is that it
038     * only works with Java.
039     * </p>
040     *
041     * <p>
042     * Set the property <b>tunnel.servlet.hosts.allowed</b> in portal.properties to
043     * configure security.
044     * </p>
045     *
046     * <p>
047     * The HTTP utility is only generated for remote services.
048     * </p>
049     *
050     * @author Brian Wing Shun Chan
051     * @see JournalArticleServiceSoap
052     * @see com.liferay.portal.security.auth.HttpPrincipal
053     * @see com.liferay.portlet.journal.service.JournalArticleServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class JournalArticleServiceHttp {
058            public static com.liferay.portlet.journal.model.JournalArticle addArticle(
059                    HttpPrincipal httpPrincipal, long groupId, long folderId,
060                    long classNameId, long classPK, java.lang.String articleId,
061                    boolean autoArticleId,
062                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
063                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
064                    java.lang.String content, java.lang.String type,
065                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
066                    java.lang.String layoutUuid, int displayDateMonth, int displayDateDay,
067                    int displayDateYear, int displayDateHour, int displayDateMinute,
068                    int expirationDateMonth, int expirationDateDay, int expirationDateYear,
069                    int expirationDateHour, int expirationDateMinute, boolean neverExpire,
070                    int reviewDateMonth, int reviewDateDay, int reviewDateYear,
071                    int reviewDateHour, int reviewDateMinute, boolean neverReview,
072                    boolean indexable, boolean smallImage, java.lang.String smallImageURL,
073                    java.io.File smallFile, java.util.Map<java.lang.String, byte[]> images,
074                    java.lang.String articleURL,
075                    com.liferay.portal.service.ServiceContext serviceContext)
076                    throws com.liferay.portal.kernel.exception.PortalException {
077                    try {
078                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
079                                            "addArticle", _addArticleParameterTypes0);
080    
081                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
082                                            folderId, classNameId, classPK, articleId, autoArticleId,
083                                            titleMap, descriptionMap, content, type, ddmStructureKey,
084                                            ddmTemplateKey, layoutUuid, displayDateMonth,
085                                            displayDateDay, displayDateYear, displayDateHour,
086                                            displayDateMinute, expirationDateMonth, expirationDateDay,
087                                            expirationDateYear, expirationDateHour,
088                                            expirationDateMinute, neverExpire, reviewDateMonth,
089                                            reviewDateDay, reviewDateYear, reviewDateHour,
090                                            reviewDateMinute, neverReview, indexable, smallImage,
091                                            smallImageURL, smallFile, images, articleURL, serviceContext);
092    
093                            Object returnObj = null;
094    
095                            try {
096                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
097                            }
098                            catch (Exception e) {
099                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
100                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
101                                    }
102    
103                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
104                            }
105    
106                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
107                    }
108                    catch (com.liferay.portal.kernel.exception.SystemException se) {
109                            _log.error(se, se);
110    
111                            throw se;
112                    }
113            }
114    
115            public static com.liferay.portlet.journal.model.JournalArticle addArticle(
116                    HttpPrincipal httpPrincipal, long groupId, long folderId,
117                    long classNameId, long classPK, java.lang.String articleId,
118                    boolean autoArticleId,
119                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
120                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
121                    java.lang.String content, java.lang.String type,
122                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
123                    java.lang.String layoutUuid, int displayDateMonth, int displayDateDay,
124                    int displayDateYear, int displayDateHour, int displayDateMinute,
125                    int expirationDateMonth, int expirationDateDay, int expirationDateYear,
126                    int expirationDateHour, int expirationDateMinute, boolean neverExpire,
127                    int reviewDateMonth, int reviewDateDay, int reviewDateYear,
128                    int reviewDateHour, int reviewDateMinute, boolean neverReview,
129                    boolean indexable, java.lang.String articleURL,
130                    com.liferay.portal.service.ServiceContext serviceContext)
131                    throws com.liferay.portal.kernel.exception.PortalException {
132                    try {
133                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
134                                            "addArticle", _addArticleParameterTypes1);
135    
136                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
137                                            folderId, classNameId, classPK, articleId, autoArticleId,
138                                            titleMap, descriptionMap, content, type, ddmStructureKey,
139                                            ddmTemplateKey, layoutUuid, displayDateMonth,
140                                            displayDateDay, displayDateYear, displayDateHour,
141                                            displayDateMinute, expirationDateMonth, expirationDateDay,
142                                            expirationDateYear, expirationDateHour,
143                                            expirationDateMinute, neverExpire, reviewDateMonth,
144                                            reviewDateDay, reviewDateYear, reviewDateHour,
145                                            reviewDateMinute, neverReview, indexable, articleURL,
146                                            serviceContext);
147    
148                            Object returnObj = null;
149    
150                            try {
151                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
152                            }
153                            catch (Exception e) {
154                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
155                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
156                                    }
157    
158                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
159                            }
160    
161                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
162                    }
163                    catch (com.liferay.portal.kernel.exception.SystemException se) {
164                            _log.error(se, se);
165    
166                            throw se;
167                    }
168            }
169    
170            public static com.liferay.portlet.journal.model.JournalArticle copyArticle(
171                    HttpPrincipal httpPrincipal, long groupId,
172                    java.lang.String oldArticleId, java.lang.String newArticleId,
173                    boolean autoArticleId, double version)
174                    throws com.liferay.portal.kernel.exception.PortalException {
175                    try {
176                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
177                                            "copyArticle", _copyArticleParameterTypes2);
178    
179                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
180                                            oldArticleId, newArticleId, autoArticleId, version);
181    
182                            Object returnObj = null;
183    
184                            try {
185                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
186                            }
187                            catch (Exception e) {
188                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
189                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
190                                    }
191    
192                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
193                            }
194    
195                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
196                    }
197                    catch (com.liferay.portal.kernel.exception.SystemException se) {
198                            _log.error(se, se);
199    
200                            throw se;
201                    }
202            }
203    
204            public static void deleteArticle(HttpPrincipal httpPrincipal, long groupId,
205                    java.lang.String articleId, double version,
206                    java.lang.String articleURL,
207                    com.liferay.portal.service.ServiceContext serviceContext)
208                    throws com.liferay.portal.kernel.exception.PortalException {
209                    try {
210                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
211                                            "deleteArticle", _deleteArticleParameterTypes3);
212    
213                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
214                                            articleId, version, articleURL, serviceContext);
215    
216                            try {
217                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
218                            }
219                            catch (Exception e) {
220                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
221                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
222                                    }
223    
224                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
225                            }
226                    }
227                    catch (com.liferay.portal.kernel.exception.SystemException se) {
228                            _log.error(se, se);
229    
230                            throw se;
231                    }
232            }
233    
234            public static void deleteArticle(HttpPrincipal httpPrincipal, long groupId,
235                    java.lang.String articleId, java.lang.String articleURL,
236                    com.liferay.portal.service.ServiceContext serviceContext)
237                    throws com.liferay.portal.kernel.exception.PortalException {
238                    try {
239                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
240                                            "deleteArticle", _deleteArticleParameterTypes4);
241    
242                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
243                                            articleId, articleURL, serviceContext);
244    
245                            try {
246                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
247                            }
248                            catch (Exception e) {
249                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
250                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
251                                    }
252    
253                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
254                            }
255                    }
256                    catch (com.liferay.portal.kernel.exception.SystemException se) {
257                            _log.error(se, se);
258    
259                            throw se;
260                    }
261            }
262    
263            public static com.liferay.portlet.journal.model.JournalArticle expireArticle(
264                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
265                    double version, java.lang.String articleURL,
266                    com.liferay.portal.service.ServiceContext serviceContext)
267                    throws com.liferay.portal.kernel.exception.PortalException {
268                    try {
269                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
270                                            "expireArticle", _expireArticleParameterTypes5);
271    
272                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
273                                            articleId, version, articleURL, serviceContext);
274    
275                            Object returnObj = null;
276    
277                            try {
278                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
279                            }
280                            catch (Exception e) {
281                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
282                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
283                                    }
284    
285                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
286                            }
287    
288                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
289                    }
290                    catch (com.liferay.portal.kernel.exception.SystemException se) {
291                            _log.error(se, se);
292    
293                            throw se;
294                    }
295            }
296    
297            public static void expireArticle(HttpPrincipal httpPrincipal, long groupId,
298                    java.lang.String articleId, java.lang.String articleURL,
299                    com.liferay.portal.service.ServiceContext serviceContext)
300                    throws com.liferay.portal.kernel.exception.PortalException {
301                    try {
302                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
303                                            "expireArticle", _expireArticleParameterTypes6);
304    
305                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
306                                            articleId, articleURL, serviceContext);
307    
308                            try {
309                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
310                            }
311                            catch (Exception e) {
312                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
313                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
314                                    }
315    
316                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
317                            }
318                    }
319                    catch (com.liferay.portal.kernel.exception.SystemException se) {
320                            _log.error(se, se);
321    
322                            throw se;
323                    }
324            }
325    
326            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
327                    HttpPrincipal httpPrincipal, long id)
328                    throws com.liferay.portal.kernel.exception.PortalException {
329                    try {
330                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
331                                            "getArticle", _getArticleParameterTypes7);
332    
333                            MethodHandler methodHandler = new MethodHandler(methodKey, id);
334    
335                            Object returnObj = null;
336    
337                            try {
338                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
339                            }
340                            catch (Exception e) {
341                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
342                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
343                                    }
344    
345                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
346                            }
347    
348                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
349                    }
350                    catch (com.liferay.portal.kernel.exception.SystemException se) {
351                            _log.error(se, se);
352    
353                            throw se;
354                    }
355            }
356    
357            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
358                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId)
359                    throws com.liferay.portal.kernel.exception.PortalException {
360                    try {
361                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
362                                            "getArticle", _getArticleParameterTypes8);
363    
364                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
365                                            articleId);
366    
367                            Object returnObj = null;
368    
369                            try {
370                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
371                            }
372                            catch (Exception e) {
373                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
374                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
375                                    }
376    
377                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
378                            }
379    
380                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
381                    }
382                    catch (com.liferay.portal.kernel.exception.SystemException se) {
383                            _log.error(se, se);
384    
385                            throw se;
386                    }
387            }
388    
389            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
390                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
391                    double version)
392                    throws com.liferay.portal.kernel.exception.PortalException {
393                    try {
394                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
395                                            "getArticle", _getArticleParameterTypes9);
396    
397                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
398                                            articleId, version);
399    
400                            Object returnObj = null;
401    
402                            try {
403                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
404                            }
405                            catch (Exception e) {
406                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
407                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
408                                    }
409    
410                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
411                            }
412    
413                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
414                    }
415                    catch (com.liferay.portal.kernel.exception.SystemException se) {
416                            _log.error(se, se);
417    
418                            throw se;
419                    }
420            }
421    
422            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
423                    HttpPrincipal httpPrincipal, long groupId, java.lang.String className,
424                    long classPK)
425                    throws com.liferay.portal.kernel.exception.PortalException {
426                    try {
427                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
428                                            "getArticle", _getArticleParameterTypes10);
429    
430                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
431                                            className, classPK);
432    
433                            Object returnObj = null;
434    
435                            try {
436                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
437                            }
438                            catch (Exception e) {
439                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
440                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
441                                    }
442    
443                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
444                            }
445    
446                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
447                    }
448                    catch (com.liferay.portal.kernel.exception.SystemException se) {
449                            _log.error(se, se);
450    
451                            throw se;
452                    }
453            }
454    
455            public static com.liferay.portlet.journal.model.JournalArticle getArticleByUrlTitle(
456                    HttpPrincipal httpPrincipal, long groupId, java.lang.String urlTitle)
457                    throws com.liferay.portal.kernel.exception.PortalException {
458                    try {
459                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
460                                            "getArticleByUrlTitle",
461                                            _getArticleByUrlTitleParameterTypes11);
462    
463                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
464                                            urlTitle);
465    
466                            Object returnObj = null;
467    
468                            try {
469                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
470                            }
471                            catch (Exception e) {
472                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
473                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
474                                    }
475    
476                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
477                            }
478    
479                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
480                    }
481                    catch (com.liferay.portal.kernel.exception.SystemException se) {
482                            _log.error(se, se);
483    
484                            throw se;
485                    }
486            }
487    
488            public static java.lang.String getArticleContent(
489                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
490                    double version, java.lang.String languageId,
491                    com.liferay.portal.kernel.portlet.PortletRequestModel portletRequestModel,
492                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
493                    throws com.liferay.portal.kernel.exception.PortalException {
494                    try {
495                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
496                                            "getArticleContent", _getArticleContentParameterTypes12);
497    
498                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
499                                            articleId, version, languageId, portletRequestModel,
500                                            themeDisplay);
501    
502                            Object returnObj = null;
503    
504                            try {
505                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
506                            }
507                            catch (Exception e) {
508                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
509                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
510                                    }
511    
512                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
513                            }
514    
515                            return (java.lang.String)returnObj;
516                    }
517                    catch (com.liferay.portal.kernel.exception.SystemException se) {
518                            _log.error(se, se);
519    
520                            throw se;
521                    }
522            }
523    
524            public static java.lang.String getArticleContent(
525                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
526                    double version, java.lang.String languageId,
527                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
528                    throws com.liferay.portal.kernel.exception.PortalException {
529                    try {
530                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
531                                            "getArticleContent", _getArticleContentParameterTypes13);
532    
533                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
534                                            articleId, version, languageId, themeDisplay);
535    
536                            Object returnObj = null;
537    
538                            try {
539                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
540                            }
541                            catch (Exception e) {
542                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
543                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
544                                    }
545    
546                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
547                            }
548    
549                            return (java.lang.String)returnObj;
550                    }
551                    catch (com.liferay.portal.kernel.exception.SystemException se) {
552                            _log.error(se, se);
553    
554                            throw se;
555                    }
556            }
557    
558            public static java.lang.String getArticleContent(
559                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
560                    java.lang.String languageId,
561                    com.liferay.portal.kernel.portlet.PortletRequestModel portletRequestModel,
562                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
563                    throws com.liferay.portal.kernel.exception.PortalException {
564                    try {
565                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
566                                            "getArticleContent", _getArticleContentParameterTypes14);
567    
568                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
569                                            articleId, languageId, portletRequestModel, themeDisplay);
570    
571                            Object returnObj = null;
572    
573                            try {
574                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
575                            }
576                            catch (Exception e) {
577                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
578                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
579                                    }
580    
581                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
582                            }
583    
584                            return (java.lang.String)returnObj;
585                    }
586                    catch (com.liferay.portal.kernel.exception.SystemException se) {
587                            _log.error(se, se);
588    
589                            throw se;
590                    }
591            }
592    
593            public static java.lang.String getArticleContent(
594                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
595                    java.lang.String languageId,
596                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
597                    throws com.liferay.portal.kernel.exception.PortalException {
598                    try {
599                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
600                                            "getArticleContent", _getArticleContentParameterTypes15);
601    
602                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
603                                            articleId, languageId, themeDisplay);
604    
605                            Object returnObj = null;
606    
607                            try {
608                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
609                            }
610                            catch (Exception e) {
611                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
612                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
613                                    }
614    
615                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
616                            }
617    
618                            return (java.lang.String)returnObj;
619                    }
620                    catch (com.liferay.portal.kernel.exception.SystemException se) {
621                            _log.error(se, se);
622    
623                            throw se;
624                    }
625            }
626    
627            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticles(
628                    HttpPrincipal httpPrincipal, long groupId, long folderId) {
629                    try {
630                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
631                                            "getArticles", _getArticlesParameterTypes16);
632    
633                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
634                                            folderId);
635    
636                            Object returnObj = null;
637    
638                            try {
639                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
640                            }
641                            catch (Exception e) {
642                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
643                            }
644    
645                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
646                    }
647                    catch (com.liferay.portal.kernel.exception.SystemException se) {
648                            _log.error(se, se);
649    
650                            throw se;
651                    }
652            }
653    
654            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticles(
655                    HttpPrincipal httpPrincipal, long groupId, long folderId, int start,
656                    int end,
657                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
658                    try {
659                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
660                                            "getArticles", _getArticlesParameterTypes17);
661    
662                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
663                                            folderId, start, end, obc);
664    
665                            Object returnObj = null;
666    
667                            try {
668                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
669                            }
670                            catch (Exception e) {
671                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
672                            }
673    
674                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
675                    }
676                    catch (com.liferay.portal.kernel.exception.SystemException se) {
677                            _log.error(se, se);
678    
679                            throw se;
680                    }
681            }
682    
683            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByArticleId(
684                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
685                    int start, int end,
686                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
687                    try {
688                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
689                                            "getArticlesByArticleId",
690                                            _getArticlesByArticleIdParameterTypes18);
691    
692                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
693                                            articleId, start, end, obc);
694    
695                            Object returnObj = null;
696    
697                            try {
698                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
699                            }
700                            catch (Exception e) {
701                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
702                            }
703    
704                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
705                    }
706                    catch (com.liferay.portal.kernel.exception.SystemException se) {
707                            _log.error(se, se);
708    
709                            throw se;
710                    }
711            }
712    
713            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByLayoutUuid(
714                    HttpPrincipal httpPrincipal, long groupId, java.lang.String layoutUuid) {
715                    try {
716                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
717                                            "getArticlesByLayoutUuid",
718                                            _getArticlesByLayoutUuidParameterTypes19);
719    
720                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
721                                            layoutUuid);
722    
723                            Object returnObj = null;
724    
725                            try {
726                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
727                            }
728                            catch (Exception e) {
729                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
730                            }
731    
732                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
733                    }
734                    catch (com.liferay.portal.kernel.exception.SystemException se) {
735                            _log.error(se, se);
736    
737                            throw se;
738                    }
739            }
740    
741            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByStructureId(
742                    HttpPrincipal httpPrincipal, long groupId, long classNameId,
743                    java.lang.String ddmStructureKey, int status, int start, int end,
744                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
745                    try {
746                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
747                                            "getArticlesByStructureId",
748                                            _getArticlesByStructureIdParameterTypes20);
749    
750                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
751                                            classNameId, ddmStructureKey, status, start, end, obc);
752    
753                            Object returnObj = null;
754    
755                            try {
756                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
757                            }
758                            catch (Exception e) {
759                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
760                            }
761    
762                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
763                    }
764                    catch (com.liferay.portal.kernel.exception.SystemException se) {
765                            _log.error(se, se);
766    
767                            throw se;
768                    }
769            }
770    
771            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByStructureId(
772                    HttpPrincipal httpPrincipal, long groupId,
773                    java.lang.String ddmStructureKey, int start, int end,
774                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
775                    try {
776                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
777                                            "getArticlesByStructureId",
778                                            _getArticlesByStructureIdParameterTypes21);
779    
780                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
781                                            ddmStructureKey, start, end, obc);
782    
783                            Object returnObj = null;
784    
785                            try {
786                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
787                            }
788                            catch (Exception e) {
789                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
790                            }
791    
792                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
793                    }
794                    catch (com.liferay.portal.kernel.exception.SystemException se) {
795                            _log.error(se, se);
796    
797                            throw se;
798                    }
799            }
800    
801            public static int getArticlesCount(HttpPrincipal httpPrincipal,
802                    long groupId, long folderId) {
803                    try {
804                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
805                                            "getArticlesCount", _getArticlesCountParameterTypes22);
806    
807                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
808                                            folderId);
809    
810                            Object returnObj = null;
811    
812                            try {
813                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
814                            }
815                            catch (Exception e) {
816                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
817                            }
818    
819                            return ((Integer)returnObj).intValue();
820                    }
821                    catch (com.liferay.portal.kernel.exception.SystemException se) {
822                            _log.error(se, se);
823    
824                            throw se;
825                    }
826            }
827    
828            public static int getArticlesCount(HttpPrincipal httpPrincipal,
829                    long groupId, long folderId, int status) {
830                    try {
831                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
832                                            "getArticlesCount", _getArticlesCountParameterTypes23);
833    
834                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
835                                            folderId, status);
836    
837                            Object returnObj = null;
838    
839                            try {
840                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
841                            }
842                            catch (Exception e) {
843                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
844                            }
845    
846                            return ((Integer)returnObj).intValue();
847                    }
848                    catch (com.liferay.portal.kernel.exception.SystemException se) {
849                            _log.error(se, se);
850    
851                            throw se;
852                    }
853            }
854    
855            public static int getArticlesCountByArticleId(HttpPrincipal httpPrincipal,
856                    long groupId, java.lang.String articleId) {
857                    try {
858                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
859                                            "getArticlesCountByArticleId",
860                                            _getArticlesCountByArticleIdParameterTypes24);
861    
862                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
863                                            articleId);
864    
865                            Object returnObj = null;
866    
867                            try {
868                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
869                            }
870                            catch (Exception e) {
871                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
872                            }
873    
874                            return ((Integer)returnObj).intValue();
875                    }
876                    catch (com.liferay.portal.kernel.exception.SystemException se) {
877                            _log.error(se, se);
878    
879                            throw se;
880                    }
881            }
882    
883            public static int getArticlesCountByStructureId(
884                    HttpPrincipal httpPrincipal, long groupId, long classNameId,
885                    java.lang.String ddmStructureKey, int status) {
886                    try {
887                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
888                                            "getArticlesCountByStructureId",
889                                            _getArticlesCountByStructureIdParameterTypes25);
890    
891                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
892                                            classNameId, ddmStructureKey, status);
893    
894                            Object returnObj = null;
895    
896                            try {
897                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
898                            }
899                            catch (Exception e) {
900                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
901                            }
902    
903                            return ((Integer)returnObj).intValue();
904                    }
905                    catch (com.liferay.portal.kernel.exception.SystemException se) {
906                            _log.error(se, se);
907    
908                            throw se;
909                    }
910            }
911    
912            public static int getArticlesCountByStructureId(
913                    HttpPrincipal httpPrincipal, long groupId,
914                    java.lang.String ddmStructureKey) {
915                    try {
916                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
917                                            "getArticlesCountByStructureId",
918                                            _getArticlesCountByStructureIdParameterTypes26);
919    
920                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
921                                            ddmStructureKey);
922    
923                            Object returnObj = null;
924    
925                            try {
926                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
927                            }
928                            catch (Exception e) {
929                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
930                            }
931    
932                            return ((Integer)returnObj).intValue();
933                    }
934                    catch (com.liferay.portal.kernel.exception.SystemException se) {
935                            _log.error(se, se);
936    
937                            throw se;
938                    }
939            }
940    
941            public static com.liferay.portlet.journal.model.JournalArticle getDisplayArticleByUrlTitle(
942                    HttpPrincipal httpPrincipal, long groupId, java.lang.String urlTitle)
943                    throws com.liferay.portal.kernel.exception.PortalException {
944                    try {
945                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
946                                            "getDisplayArticleByUrlTitle",
947                                            _getDisplayArticleByUrlTitleParameterTypes27);
948    
949                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
950                                            urlTitle);
951    
952                            Object returnObj = null;
953    
954                            try {
955                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
956                            }
957                            catch (Exception e) {
958                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
959                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
960                                    }
961    
962                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
963                            }
964    
965                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
966                    }
967                    catch (com.liferay.portal.kernel.exception.SystemException se) {
968                            _log.error(se, se);
969    
970                            throw se;
971                    }
972            }
973    
974            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
975                    long groupId, java.util.List<java.lang.Long> folderIds) {
976                    try {
977                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
978                                            "getFoldersAndArticlesCount",
979                                            _getFoldersAndArticlesCountParameterTypes28);
980    
981                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
982                                            folderIds);
983    
984                            Object returnObj = null;
985    
986                            try {
987                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
988                            }
989                            catch (Exception e) {
990                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
991                            }
992    
993                            return ((Integer)returnObj).intValue();
994                    }
995                    catch (com.liferay.portal.kernel.exception.SystemException se) {
996                            _log.error(se, se);
997    
998                            throw se;
999                    }
1000            }
1001    
1002            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getGroupArticles(
1003                    HttpPrincipal httpPrincipal, long groupId, long userId,
1004                    long rootFolderId, int status, int start, int end,
1005                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1006                    throws com.liferay.portal.kernel.exception.PortalException {
1007                    try {
1008                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1009                                            "getGroupArticles", _getGroupArticlesParameterTypes29);
1010    
1011                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1012                                            userId, rootFolderId, status, start, end, orderByComparator);
1013    
1014                            Object returnObj = null;
1015    
1016                            try {
1017                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1018                            }
1019                            catch (Exception e) {
1020                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1021                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1022                                    }
1023    
1024                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1025                            }
1026    
1027                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1028                    }
1029                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1030                            _log.error(se, se);
1031    
1032                            throw se;
1033                    }
1034            }
1035    
1036            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getGroupArticles(
1037                    HttpPrincipal httpPrincipal, long groupId, long userId,
1038                    long rootFolderId, int start, int end,
1039                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1040                    throws com.liferay.portal.kernel.exception.PortalException {
1041                    try {
1042                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1043                                            "getGroupArticles", _getGroupArticlesParameterTypes30);
1044    
1045                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1046                                            userId, rootFolderId, start, end, orderByComparator);
1047    
1048                            Object returnObj = null;
1049    
1050                            try {
1051                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1052                            }
1053                            catch (Exception e) {
1054                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1055                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1056                                    }
1057    
1058                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1059                            }
1060    
1061                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1062                    }
1063                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1064                            _log.error(se, se);
1065    
1066                            throw se;
1067                    }
1068            }
1069    
1070            public static int getGroupArticlesCount(HttpPrincipal httpPrincipal,
1071                    long groupId, long userId, long rootFolderId)
1072                    throws com.liferay.portal.kernel.exception.PortalException {
1073                    try {
1074                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1075                                            "getGroupArticlesCount",
1076                                            _getGroupArticlesCountParameterTypes31);
1077    
1078                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1079                                            userId, rootFolderId);
1080    
1081                            Object returnObj = null;
1082    
1083                            try {
1084                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1085                            }
1086                            catch (Exception e) {
1087                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1088                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1089                                    }
1090    
1091                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1092                            }
1093    
1094                            return ((Integer)returnObj).intValue();
1095                    }
1096                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1097                            _log.error(se, se);
1098    
1099                            throw se;
1100                    }
1101            }
1102    
1103            public static int getGroupArticlesCount(HttpPrincipal httpPrincipal,
1104                    long groupId, long userId, long rootFolderId, int status)
1105                    throws com.liferay.portal.kernel.exception.PortalException {
1106                    try {
1107                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1108                                            "getGroupArticlesCount",
1109                                            _getGroupArticlesCountParameterTypes32);
1110    
1111                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1112                                            userId, rootFolderId, status);
1113    
1114                            Object returnObj = null;
1115    
1116                            try {
1117                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1118                            }
1119                            catch (Exception e) {
1120                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1121                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1122                                    }
1123    
1124                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1125                            }
1126    
1127                            return ((Integer)returnObj).intValue();
1128                    }
1129                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1130                            _log.error(se, se);
1131    
1132                            throw se;
1133                    }
1134            }
1135    
1136            public static com.liferay.portlet.journal.model.JournalArticle getLatestArticle(
1137                    HttpPrincipal httpPrincipal, long resourcePrimKey)
1138                    throws com.liferay.portal.kernel.exception.PortalException {
1139                    try {
1140                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1141                                            "getLatestArticle", _getLatestArticleParameterTypes33);
1142    
1143                            MethodHandler methodHandler = new MethodHandler(methodKey,
1144                                            resourcePrimKey);
1145    
1146                            Object returnObj = null;
1147    
1148                            try {
1149                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1150                            }
1151                            catch (Exception e) {
1152                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1153                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1154                                    }
1155    
1156                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1157                            }
1158    
1159                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1160                    }
1161                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1162                            _log.error(se, se);
1163    
1164                            throw se;
1165                    }
1166            }
1167    
1168            public static com.liferay.portlet.journal.model.JournalArticle getLatestArticle(
1169                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1170                    int status) throws com.liferay.portal.kernel.exception.PortalException {
1171                    try {
1172                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1173                                            "getLatestArticle", _getLatestArticleParameterTypes34);
1174    
1175                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1176                                            articleId, status);
1177    
1178                            Object returnObj = null;
1179    
1180                            try {
1181                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1182                            }
1183                            catch (Exception e) {
1184                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1185                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1186                                    }
1187    
1188                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1189                            }
1190    
1191                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1192                    }
1193                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1194                            _log.error(se, se);
1195    
1196                            throw se;
1197                    }
1198            }
1199    
1200            public static com.liferay.portlet.journal.model.JournalArticle getLatestArticle(
1201                    HttpPrincipal httpPrincipal, long groupId, java.lang.String className,
1202                    long classPK)
1203                    throws com.liferay.portal.kernel.exception.PortalException {
1204                    try {
1205                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1206                                            "getLatestArticle", _getLatestArticleParameterTypes35);
1207    
1208                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1209                                            className, classPK);
1210    
1211                            Object returnObj = null;
1212    
1213                            try {
1214                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1215                            }
1216                            catch (Exception e) {
1217                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1218                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1219                                    }
1220    
1221                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1222                            }
1223    
1224                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1225                    }
1226                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1227                            _log.error(se, se);
1228    
1229                            throw se;
1230                    }
1231            }
1232    
1233            public static void moveArticle(HttpPrincipal httpPrincipal, long groupId,
1234                    java.lang.String articleId, long newFolderId)
1235                    throws com.liferay.portal.kernel.exception.PortalException {
1236                    try {
1237                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1238                                            "moveArticle", _moveArticleParameterTypes36);
1239    
1240                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1241                                            articleId, newFolderId);
1242    
1243                            try {
1244                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1245                            }
1246                            catch (Exception e) {
1247                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1248                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1249                                    }
1250    
1251                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1252                            }
1253                    }
1254                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1255                            _log.error(se, se);
1256    
1257                            throw se;
1258                    }
1259            }
1260    
1261            public static com.liferay.portlet.journal.model.JournalArticle moveArticleFromTrash(
1262                    HttpPrincipal httpPrincipal, long groupId, long resourcePrimKey,
1263                    long newFolderId,
1264                    com.liferay.portal.service.ServiceContext serviceContext)
1265                    throws com.liferay.portal.kernel.exception.PortalException {
1266                    try {
1267                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1268                                            "moveArticleFromTrash",
1269                                            _moveArticleFromTrashParameterTypes37);
1270    
1271                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1272                                            resourcePrimKey, newFolderId, serviceContext);
1273    
1274                            Object returnObj = null;
1275    
1276                            try {
1277                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1278                            }
1279                            catch (Exception e) {
1280                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1281                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1282                                    }
1283    
1284                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1285                            }
1286    
1287                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1288                    }
1289                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1290                            _log.error(se, se);
1291    
1292                            throw se;
1293                    }
1294            }
1295    
1296            public static com.liferay.portlet.journal.model.JournalArticle moveArticleFromTrash(
1297                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1298                    long newFolderId,
1299                    com.liferay.portal.service.ServiceContext serviceContext)
1300                    throws com.liferay.portal.kernel.exception.PortalException {
1301                    try {
1302                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1303                                            "moveArticleFromTrash",
1304                                            _moveArticleFromTrashParameterTypes38);
1305    
1306                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1307                                            articleId, newFolderId, serviceContext);
1308    
1309                            Object returnObj = null;
1310    
1311                            try {
1312                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1313                            }
1314                            catch (Exception e) {
1315                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1316                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1317                                    }
1318    
1319                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1320                            }
1321    
1322                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1323                    }
1324                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1325                            _log.error(se, se);
1326    
1327                            throw se;
1328                    }
1329            }
1330    
1331            public static com.liferay.portlet.journal.model.JournalArticle moveArticleToTrash(
1332                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId)
1333                    throws com.liferay.portal.kernel.exception.PortalException {
1334                    try {
1335                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1336                                            "moveArticleToTrash", _moveArticleToTrashParameterTypes39);
1337    
1338                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1339                                            articleId);
1340    
1341                            Object returnObj = null;
1342    
1343                            try {
1344                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1345                            }
1346                            catch (Exception e) {
1347                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1348                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1349                                    }
1350    
1351                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1352                            }
1353    
1354                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1355                    }
1356                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1357                            _log.error(se, se);
1358    
1359                            throw se;
1360                    }
1361            }
1362    
1363            public static void removeArticleLocale(HttpPrincipal httpPrincipal,
1364                    long companyId, java.lang.String languageId)
1365                    throws com.liferay.portal.kernel.exception.PortalException {
1366                    try {
1367                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1368                                            "removeArticleLocale", _removeArticleLocaleParameterTypes40);
1369    
1370                            MethodHandler methodHandler = new MethodHandler(methodKey,
1371                                            companyId, languageId);
1372    
1373                            try {
1374                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1375                            }
1376                            catch (Exception e) {
1377                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1378                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1379                                    }
1380    
1381                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1382                            }
1383                    }
1384                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1385                            _log.error(se, se);
1386    
1387                            throw se;
1388                    }
1389            }
1390    
1391            public static com.liferay.portlet.journal.model.JournalArticle removeArticleLocale(
1392                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1393                    double version, java.lang.String languageId)
1394                    throws com.liferay.portal.kernel.exception.PortalException {
1395                    try {
1396                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1397                                            "removeArticleLocale", _removeArticleLocaleParameterTypes41);
1398    
1399                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1400                                            articleId, version, languageId);
1401    
1402                            Object returnObj = null;
1403    
1404                            try {
1405                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1406                            }
1407                            catch (Exception e) {
1408                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1409                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1410                                    }
1411    
1412                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1413                            }
1414    
1415                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1416                    }
1417                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1418                            _log.error(se, se);
1419    
1420                            throw se;
1421                    }
1422            }
1423    
1424            public static void restoreArticleFromTrash(HttpPrincipal httpPrincipal,
1425                    long resourcePrimKey)
1426                    throws com.liferay.portal.kernel.exception.PortalException {
1427                    try {
1428                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1429                                            "restoreArticleFromTrash",
1430                                            _restoreArticleFromTrashParameterTypes42);
1431    
1432                            MethodHandler methodHandler = new MethodHandler(methodKey,
1433                                            resourcePrimKey);
1434    
1435                            try {
1436                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1437                            }
1438                            catch (Exception e) {
1439                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1440                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1441                                    }
1442    
1443                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1444                            }
1445                    }
1446                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1447                            _log.error(se, se);
1448    
1449                            throw se;
1450                    }
1451            }
1452    
1453            public static void restoreArticleFromTrash(HttpPrincipal httpPrincipal,
1454                    long groupId, java.lang.String articleId)
1455                    throws com.liferay.portal.kernel.exception.PortalException {
1456                    try {
1457                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1458                                            "restoreArticleFromTrash",
1459                                            _restoreArticleFromTrashParameterTypes43);
1460    
1461                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1462                                            articleId);
1463    
1464                            try {
1465                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1466                            }
1467                            catch (Exception e) {
1468                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1469                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1470                                    }
1471    
1472                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1473                            }
1474                    }
1475                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1476                            _log.error(se, se);
1477    
1478                            throw se;
1479                    }
1480            }
1481    
1482            public static com.liferay.portal.kernel.search.Hits search(
1483                    HttpPrincipal httpPrincipal, long groupId, long creatorUserId,
1484                    int status, int start, int end)
1485                    throws com.liferay.portal.kernel.exception.PortalException {
1486                    try {
1487                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1488                                            "search", _searchParameterTypes44);
1489    
1490                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1491                                            creatorUserId, status, start, end);
1492    
1493                            Object returnObj = null;
1494    
1495                            try {
1496                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1497                            }
1498                            catch (Exception e) {
1499                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1500                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1501                                    }
1502    
1503                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1504                            }
1505    
1506                            return (com.liferay.portal.kernel.search.Hits)returnObj;
1507                    }
1508                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1509                            _log.error(se, se);
1510    
1511                            throw se;
1512                    }
1513            }
1514    
1515            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1516                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1517                    java.util.List<java.lang.Long> folderIds, long classNameId,
1518                    java.lang.String keywords, java.lang.Double version,
1519                    java.lang.String type, java.lang.String ddmStructureKey,
1520                    java.lang.String ddmTemplateKey, java.util.Date displayDateGT,
1521                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1522                    int start, int end,
1523                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1524                    try {
1525                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1526                                            "search", _searchParameterTypes45);
1527    
1528                            MethodHandler methodHandler = new MethodHandler(methodKey,
1529                                            companyId, groupId, folderIds, classNameId, keywords,
1530                                            version, type, ddmStructureKey, ddmTemplateKey,
1531                                            displayDateGT, displayDateLT, status, reviewDate, start,
1532                                            end, obc);
1533    
1534                            Object returnObj = null;
1535    
1536                            try {
1537                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1538                            }
1539                            catch (Exception e) {
1540                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1541                            }
1542    
1543                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1544                    }
1545                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1546                            _log.error(se, se);
1547    
1548                            throw se;
1549                    }
1550            }
1551    
1552            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1553                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1554                    java.util.List<java.lang.Long> folderIds, long classNameId,
1555                    java.lang.String articleId, java.lang.Double version,
1556                    java.lang.String title, java.lang.String description,
1557                    java.lang.String content, java.lang.String type,
1558                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
1559                    java.util.Date displayDateGT, java.util.Date displayDateLT, int status,
1560                    java.util.Date reviewDate, boolean andOperator, int start, int end,
1561                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1562                    try {
1563                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1564                                            "search", _searchParameterTypes46);
1565    
1566                            MethodHandler methodHandler = new MethodHandler(methodKey,
1567                                            companyId, groupId, folderIds, classNameId, articleId,
1568                                            version, title, description, content, type,
1569                                            ddmStructureKey, ddmTemplateKey, displayDateGT,
1570                                            displayDateLT, status, reviewDate, andOperator, start, end,
1571                                            obc);
1572    
1573                            Object returnObj = null;
1574    
1575                            try {
1576                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1577                            }
1578                            catch (Exception e) {
1579                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1580                            }
1581    
1582                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1583                    }
1584                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1585                            _log.error(se, se);
1586    
1587                            throw se;
1588                    }
1589            }
1590    
1591            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1592                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1593                    java.util.List<java.lang.Long> folderIds, long classNameId,
1594                    java.lang.String articleId, java.lang.Double version,
1595                    java.lang.String title, java.lang.String description,
1596                    java.lang.String content, java.lang.String type,
1597                    java.lang.String[] ddmStructureKeys,
1598                    java.lang.String[] ddmTemplateKeys, java.util.Date displayDateGT,
1599                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1600                    boolean andOperator, int start, int end,
1601                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1602                    try {
1603                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1604                                            "search", _searchParameterTypes47);
1605    
1606                            MethodHandler methodHandler = new MethodHandler(methodKey,
1607                                            companyId, groupId, folderIds, classNameId, articleId,
1608                                            version, title, description, content, type,
1609                                            ddmStructureKeys, ddmTemplateKeys, displayDateGT,
1610                                            displayDateLT, status, reviewDate, andOperator, start, end,
1611                                            obc);
1612    
1613                            Object returnObj = null;
1614    
1615                            try {
1616                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1617                            }
1618                            catch (Exception e) {
1619                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1620                            }
1621    
1622                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1623                    }
1624                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1625                            _log.error(se, se);
1626    
1627                            throw se;
1628                    }
1629            }
1630    
1631            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1632                    long groupId, java.util.List<java.lang.Long> folderIds,
1633                    long classNameId, java.lang.String keywords, java.lang.Double version,
1634                    java.lang.String type, java.lang.String ddmStructureKey,
1635                    java.lang.String ddmTemplateKey, java.util.Date displayDateGT,
1636                    java.util.Date displayDateLT, int status, java.util.Date reviewDate) {
1637                    try {
1638                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1639                                            "searchCount", _searchCountParameterTypes48);
1640    
1641                            MethodHandler methodHandler = new MethodHandler(methodKey,
1642                                            companyId, groupId, folderIds, classNameId, keywords,
1643                                            version, type, ddmStructureKey, ddmTemplateKey,
1644                                            displayDateGT, displayDateLT, status, reviewDate);
1645    
1646                            Object returnObj = null;
1647    
1648                            try {
1649                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1650                            }
1651                            catch (Exception e) {
1652                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1653                            }
1654    
1655                            return ((Integer)returnObj).intValue();
1656                    }
1657                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1658                            _log.error(se, se);
1659    
1660                            throw se;
1661                    }
1662            }
1663    
1664            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1665                    long groupId, java.util.List<java.lang.Long> folderIds,
1666                    long classNameId, java.lang.String articleId, java.lang.Double version,
1667                    java.lang.String title, java.lang.String description,
1668                    java.lang.String content, java.lang.String type,
1669                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
1670                    java.util.Date displayDateGT, java.util.Date displayDateLT, int status,
1671                    java.util.Date reviewDate, boolean andOperator) {
1672                    try {
1673                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1674                                            "searchCount", _searchCountParameterTypes49);
1675    
1676                            MethodHandler methodHandler = new MethodHandler(methodKey,
1677                                            companyId, groupId, folderIds, classNameId, articleId,
1678                                            version, title, description, content, type,
1679                                            ddmStructureKey, ddmTemplateKey, displayDateGT,
1680                                            displayDateLT, status, reviewDate, andOperator);
1681    
1682                            Object returnObj = null;
1683    
1684                            try {
1685                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1686                            }
1687                            catch (Exception e) {
1688                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1689                            }
1690    
1691                            return ((Integer)returnObj).intValue();
1692                    }
1693                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1694                            _log.error(se, se);
1695    
1696                            throw se;
1697                    }
1698            }
1699    
1700            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1701                    long groupId, java.util.List<java.lang.Long> folderIds,
1702                    long classNameId, java.lang.String articleId, java.lang.Double version,
1703                    java.lang.String title, java.lang.String description,
1704                    java.lang.String content, java.lang.String type,
1705                    java.lang.String[] ddmStructureKeys,
1706                    java.lang.String[] ddmTemplateKeys, java.util.Date displayDateGT,
1707                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1708                    boolean andOperator) {
1709                    try {
1710                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1711                                            "searchCount", _searchCountParameterTypes50);
1712    
1713                            MethodHandler methodHandler = new MethodHandler(methodKey,
1714                                            companyId, groupId, folderIds, classNameId, articleId,
1715                                            version, title, description, content, type,
1716                                            ddmStructureKeys, ddmTemplateKeys, displayDateGT,
1717                                            displayDateLT, status, reviewDate, andOperator);
1718    
1719                            Object returnObj = null;
1720    
1721                            try {
1722                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1723                            }
1724                            catch (Exception e) {
1725                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1726                            }
1727    
1728                            return ((Integer)returnObj).intValue();
1729                    }
1730                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1731                            _log.error(se, se);
1732    
1733                            throw se;
1734                    }
1735            }
1736    
1737            public static void subscribeStructure(HttpPrincipal httpPrincipal,
1738                    long groupId, long userId, long ddmStructureId)
1739                    throws com.liferay.portal.kernel.exception.PortalException {
1740                    try {
1741                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1742                                            "subscribeStructure", _subscribeStructureParameterTypes51);
1743    
1744                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1745                                            userId, ddmStructureId);
1746    
1747                            try {
1748                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1749                            }
1750                            catch (Exception e) {
1751                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1752                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1753                                    }
1754    
1755                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1756                            }
1757                    }
1758                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1759                            _log.error(se, se);
1760    
1761                            throw se;
1762                    }
1763            }
1764    
1765            public static void unsubscribeStructure(HttpPrincipal httpPrincipal,
1766                    long groupId, long userId, long ddmStructureId)
1767                    throws com.liferay.portal.kernel.exception.PortalException {
1768                    try {
1769                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1770                                            "unsubscribeStructure",
1771                                            _unsubscribeStructureParameterTypes52);
1772    
1773                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1774                                            userId, ddmStructureId);
1775    
1776                            try {
1777                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1778                            }
1779                            catch (Exception e) {
1780                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1781                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1782                                    }
1783    
1784                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1785                            }
1786                    }
1787                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1788                            _log.error(se, se);
1789    
1790                            throw se;
1791                    }
1792            }
1793    
1794            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1795                    HttpPrincipal httpPrincipal, long userId, long groupId, long folderId,
1796                    java.lang.String articleId, double version,
1797                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1798                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1799                    java.lang.String content, java.lang.String layoutUuid,
1800                    com.liferay.portal.service.ServiceContext serviceContext)
1801                    throws com.liferay.portal.kernel.exception.PortalException {
1802                    try {
1803                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1804                                            "updateArticle", _updateArticleParameterTypes53);
1805    
1806                            MethodHandler methodHandler = new MethodHandler(methodKey, userId,
1807                                            groupId, folderId, articleId, version, titleMap,
1808                                            descriptionMap, content, layoutUuid, serviceContext);
1809    
1810                            Object returnObj = null;
1811    
1812                            try {
1813                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1814                            }
1815                            catch (Exception e) {
1816                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1817                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1818                                    }
1819    
1820                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1821                            }
1822    
1823                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1824                    }
1825                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1826                            _log.error(se, se);
1827    
1828                            throw se;
1829                    }
1830            }
1831    
1832            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1833                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1834                    java.lang.String articleId, double version,
1835                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1836                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1837                    java.lang.String content, java.lang.String type,
1838                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
1839                    java.lang.String layoutUuid, int displayDateMonth, int displayDateDay,
1840                    int displayDateYear, int displayDateHour, int displayDateMinute,
1841                    int expirationDateMonth, int expirationDateDay, int expirationDateYear,
1842                    int expirationDateHour, int expirationDateMinute, boolean neverExpire,
1843                    int reviewDateMonth, int reviewDateDay, int reviewDateYear,
1844                    int reviewDateHour, int reviewDateMinute, boolean neverReview,
1845                    boolean indexable, boolean smallImage, java.lang.String smallImageURL,
1846                    java.io.File smallFile, java.util.Map<java.lang.String, byte[]> images,
1847                    java.lang.String articleURL,
1848                    com.liferay.portal.service.ServiceContext serviceContext)
1849                    throws com.liferay.portal.kernel.exception.PortalException {
1850                    try {
1851                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1852                                            "updateArticle", _updateArticleParameterTypes54);
1853    
1854                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1855                                            folderId, articleId, version, titleMap, descriptionMap,
1856                                            content, type, ddmStructureKey, ddmTemplateKey, layoutUuid,
1857                                            displayDateMonth, displayDateDay, displayDateYear,
1858                                            displayDateHour, displayDateMinute, expirationDateMonth,
1859                                            expirationDateDay, expirationDateYear, expirationDateHour,
1860                                            expirationDateMinute, neverExpire, reviewDateMonth,
1861                                            reviewDateDay, reviewDateYear, reviewDateHour,
1862                                            reviewDateMinute, neverReview, indexable, smallImage,
1863                                            smallImageURL, smallFile, images, articleURL, serviceContext);
1864    
1865                            Object returnObj = null;
1866    
1867                            try {
1868                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1869                            }
1870                            catch (Exception e) {
1871                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1872                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1873                                    }
1874    
1875                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1876                            }
1877    
1878                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1879                    }
1880                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1881                            _log.error(se, se);
1882    
1883                            throw se;
1884                    }
1885            }
1886    
1887            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1888                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1889                    java.lang.String articleId, double version, java.lang.String content,
1890                    com.liferay.portal.service.ServiceContext serviceContext)
1891                    throws com.liferay.portal.kernel.exception.PortalException {
1892                    try {
1893                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1894                                            "updateArticle", _updateArticleParameterTypes55);
1895    
1896                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1897                                            folderId, articleId, version, content, serviceContext);
1898    
1899                            Object returnObj = null;
1900    
1901                            try {
1902                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1903                            }
1904                            catch (Exception e) {
1905                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1906                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1907                                    }
1908    
1909                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1910                            }
1911    
1912                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1913                    }
1914                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1915                            _log.error(se, se);
1916    
1917                            throw se;
1918                    }
1919            }
1920    
1921            public static com.liferay.portlet.journal.model.JournalArticle updateArticleTranslation(
1922                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1923                    double version, java.util.Locale locale, java.lang.String title,
1924                    java.lang.String description, java.lang.String content,
1925                    java.util.Map<java.lang.String, byte[]> images)
1926                    throws com.liferay.portal.kernel.exception.PortalException {
1927                    try {
1928                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1929                                            "updateArticleTranslation",
1930                                            _updateArticleTranslationParameterTypes56);
1931    
1932                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1933                                            articleId, version, locale, title, description, content,
1934                                            images);
1935    
1936                            Object returnObj = null;
1937    
1938                            try {
1939                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1940                            }
1941                            catch (Exception e) {
1942                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1943                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1944                                    }
1945    
1946                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1947                            }
1948    
1949                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1950                    }
1951                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1952                            _log.error(se, se);
1953    
1954                            throw se;
1955                    }
1956            }
1957    
1958            public static com.liferay.portlet.journal.model.JournalArticle updateArticleTranslation(
1959                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1960                    double version, java.util.Locale locale, java.lang.String title,
1961                    java.lang.String description, java.lang.String content,
1962                    java.util.Map<java.lang.String, byte[]> images,
1963                    com.liferay.portal.service.ServiceContext serviceContext)
1964                    throws com.liferay.portal.kernel.exception.PortalException {
1965                    try {
1966                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1967                                            "updateArticleTranslation",
1968                                            _updateArticleTranslationParameterTypes57);
1969    
1970                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1971                                            articleId, version, locale, title, description, content,
1972                                            images, serviceContext);
1973    
1974                            Object returnObj = null;
1975    
1976                            try {
1977                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1978                            }
1979                            catch (Exception e) {
1980                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1981                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1982                                    }
1983    
1984                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1985                            }
1986    
1987                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1988                    }
1989                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1990                            _log.error(se, se);
1991    
1992                            throw se;
1993                    }
1994            }
1995    
1996            public static com.liferay.portlet.journal.model.JournalArticle updateContent(
1997                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1998                    double version, java.lang.String content)
1999                    throws com.liferay.portal.kernel.exception.PortalException {
2000                    try {
2001                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
2002                                            "updateContent", _updateContentParameterTypes58);
2003    
2004                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2005                                            articleId, version, content);
2006    
2007                            Object returnObj = null;
2008    
2009                            try {
2010                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2011                            }
2012                            catch (Exception e) {
2013                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2014                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2015                                    }
2016    
2017                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2018                            }
2019    
2020                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2021                    }
2022                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2023                            _log.error(se, se);
2024    
2025                            throw se;
2026                    }
2027            }
2028    
2029            public static com.liferay.portlet.journal.model.JournalArticle updateStatus(
2030                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
2031                    double version, int status, java.lang.String articleURL,
2032                    com.liferay.portal.service.ServiceContext serviceContext)
2033                    throws com.liferay.portal.kernel.exception.PortalException {
2034                    try {
2035                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
2036                                            "updateStatus", _updateStatusParameterTypes59);
2037    
2038                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2039                                            articleId, version, status, articleURL, serviceContext);
2040    
2041                            Object returnObj = null;
2042    
2043                            try {
2044                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2045                            }
2046                            catch (Exception e) {
2047                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2048                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2049                                    }
2050    
2051                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2052                            }
2053    
2054                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2055                    }
2056                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2057                            _log.error(se, se);
2058    
2059                            throw se;
2060                    }
2061            }
2062    
2063            private static Log _log = LogFactoryUtil.getLog(JournalArticleServiceHttp.class);
2064            private static final Class<?>[] _addArticleParameterTypes0 = new Class[] {
2065                            long.class, long.class, long.class, long.class,
2066                            java.lang.String.class, boolean.class, java.util.Map.class,
2067                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2068                            java.lang.String.class, java.lang.String.class,
2069                            java.lang.String.class, int.class, int.class, int.class, int.class,
2070                            int.class, int.class, int.class, int.class, int.class, int.class,
2071                            boolean.class, int.class, int.class, int.class, int.class, int.class,
2072                            boolean.class, boolean.class, boolean.class, java.lang.String.class,
2073                            java.io.File.class, java.util.Map.class, java.lang.String.class,
2074                            com.liferay.portal.service.ServiceContext.class
2075                    };
2076            private static final Class<?>[] _addArticleParameterTypes1 = new Class[] {
2077                            long.class, long.class, long.class, long.class,
2078                            java.lang.String.class, boolean.class, java.util.Map.class,
2079                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2080                            java.lang.String.class, java.lang.String.class,
2081                            java.lang.String.class, int.class, int.class, int.class, int.class,
2082                            int.class, int.class, int.class, int.class, int.class, int.class,
2083                            boolean.class, int.class, int.class, int.class, int.class, int.class,
2084                            boolean.class, boolean.class, java.lang.String.class,
2085                            com.liferay.portal.service.ServiceContext.class
2086                    };
2087            private static final Class<?>[] _copyArticleParameterTypes2 = new Class[] {
2088                            long.class, java.lang.String.class, java.lang.String.class,
2089                            boolean.class, double.class
2090                    };
2091            private static final Class<?>[] _deleteArticleParameterTypes3 = new Class[] {
2092                            long.class, java.lang.String.class, double.class,
2093                            java.lang.String.class,
2094                            com.liferay.portal.service.ServiceContext.class
2095                    };
2096            private static final Class<?>[] _deleteArticleParameterTypes4 = new Class[] {
2097                            long.class, java.lang.String.class, java.lang.String.class,
2098                            com.liferay.portal.service.ServiceContext.class
2099                    };
2100            private static final Class<?>[] _expireArticleParameterTypes5 = new Class[] {
2101                            long.class, java.lang.String.class, double.class,
2102                            java.lang.String.class,
2103                            com.liferay.portal.service.ServiceContext.class
2104                    };
2105            private static final Class<?>[] _expireArticleParameterTypes6 = new Class[] {
2106                            long.class, java.lang.String.class, java.lang.String.class,
2107                            com.liferay.portal.service.ServiceContext.class
2108                    };
2109            private static final Class<?>[] _getArticleParameterTypes7 = new Class[] {
2110                            long.class
2111                    };
2112            private static final Class<?>[] _getArticleParameterTypes8 = new Class[] {
2113                            long.class, java.lang.String.class
2114                    };
2115            private static final Class<?>[] _getArticleParameterTypes9 = new Class[] {
2116                            long.class, java.lang.String.class, double.class
2117                    };
2118            private static final Class<?>[] _getArticleParameterTypes10 = new Class[] {
2119                            long.class, java.lang.String.class, long.class
2120                    };
2121            private static final Class<?>[] _getArticleByUrlTitleParameterTypes11 = new Class[] {
2122                            long.class, java.lang.String.class
2123                    };
2124            private static final Class<?>[] _getArticleContentParameterTypes12 = new Class[] {
2125                            long.class, java.lang.String.class, double.class,
2126                            java.lang.String.class,
2127                            com.liferay.portal.kernel.portlet.PortletRequestModel.class,
2128                            com.liferay.portal.theme.ThemeDisplay.class
2129                    };
2130            private static final Class<?>[] _getArticleContentParameterTypes13 = new Class[] {
2131                            long.class, java.lang.String.class, double.class,
2132                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
2133                    };
2134            private static final Class<?>[] _getArticleContentParameterTypes14 = new Class[] {
2135                            long.class, java.lang.String.class, java.lang.String.class,
2136                            com.liferay.portal.kernel.portlet.PortletRequestModel.class,
2137                            com.liferay.portal.theme.ThemeDisplay.class
2138                    };
2139            private static final Class<?>[] _getArticleContentParameterTypes15 = new Class[] {
2140                            long.class, java.lang.String.class, java.lang.String.class,
2141                            com.liferay.portal.theme.ThemeDisplay.class
2142                    };
2143            private static final Class<?>[] _getArticlesParameterTypes16 = new Class[] {
2144                            long.class, long.class
2145                    };
2146            private static final Class<?>[] _getArticlesParameterTypes17 = new Class[] {
2147                            long.class, long.class, int.class, int.class,
2148                            com.liferay.portal.kernel.util.OrderByComparator.class
2149                    };
2150            private static final Class<?>[] _getArticlesByArticleIdParameterTypes18 = new Class[] {
2151                            long.class, java.lang.String.class, int.class, int.class,
2152                            com.liferay.portal.kernel.util.OrderByComparator.class
2153                    };
2154            private static final Class<?>[] _getArticlesByLayoutUuidParameterTypes19 = new Class[] {
2155                            long.class, java.lang.String.class
2156                    };
2157            private static final Class<?>[] _getArticlesByStructureIdParameterTypes20 = new Class[] {
2158                            long.class, long.class, java.lang.String.class, int.class, int.class,
2159                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
2160                    };
2161            private static final Class<?>[] _getArticlesByStructureIdParameterTypes21 = new Class[] {
2162                            long.class, java.lang.String.class, int.class, int.class,
2163                            com.liferay.portal.kernel.util.OrderByComparator.class
2164                    };
2165            private static final Class<?>[] _getArticlesCountParameterTypes22 = new Class[] {
2166                            long.class, long.class
2167                    };
2168            private static final Class<?>[] _getArticlesCountParameterTypes23 = new Class[] {
2169                            long.class, long.class, int.class
2170                    };
2171            private static final Class<?>[] _getArticlesCountByArticleIdParameterTypes24 =
2172                    new Class[] { long.class, java.lang.String.class };
2173            private static final Class<?>[] _getArticlesCountByStructureIdParameterTypes25 =
2174                    new Class[] { long.class, long.class, java.lang.String.class, int.class };
2175            private static final Class<?>[] _getArticlesCountByStructureIdParameterTypes26 =
2176                    new Class[] { long.class, java.lang.String.class };
2177            private static final Class<?>[] _getDisplayArticleByUrlTitleParameterTypes27 =
2178                    new Class[] { long.class, java.lang.String.class };
2179            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes28 = new Class[] {
2180                            long.class, java.util.List.class
2181                    };
2182            private static final Class<?>[] _getGroupArticlesParameterTypes29 = new Class[] {
2183                            long.class, long.class, long.class, int.class, int.class, int.class,
2184                            com.liferay.portal.kernel.util.OrderByComparator.class
2185                    };
2186            private static final Class<?>[] _getGroupArticlesParameterTypes30 = new Class[] {
2187                            long.class, long.class, long.class, int.class, int.class,
2188                            com.liferay.portal.kernel.util.OrderByComparator.class
2189                    };
2190            private static final Class<?>[] _getGroupArticlesCountParameterTypes31 = new Class[] {
2191                            long.class, long.class, long.class
2192                    };
2193            private static final Class<?>[] _getGroupArticlesCountParameterTypes32 = new Class[] {
2194                            long.class, long.class, long.class, int.class
2195                    };
2196            private static final Class<?>[] _getLatestArticleParameterTypes33 = new Class[] {
2197                            long.class
2198                    };
2199            private static final Class<?>[] _getLatestArticleParameterTypes34 = new Class[] {
2200                            long.class, java.lang.String.class, int.class
2201                    };
2202            private static final Class<?>[] _getLatestArticleParameterTypes35 = new Class[] {
2203                            long.class, java.lang.String.class, long.class
2204                    };
2205            private static final Class<?>[] _moveArticleParameterTypes36 = new Class[] {
2206                            long.class, java.lang.String.class, long.class
2207                    };
2208            private static final Class<?>[] _moveArticleFromTrashParameterTypes37 = new Class[] {
2209                            long.class, long.class, long.class,
2210                            com.liferay.portal.service.ServiceContext.class
2211                    };
2212            private static final Class<?>[] _moveArticleFromTrashParameterTypes38 = new Class[] {
2213                            long.class, java.lang.String.class, long.class,
2214                            com.liferay.portal.service.ServiceContext.class
2215                    };
2216            private static final Class<?>[] _moveArticleToTrashParameterTypes39 = new Class[] {
2217                            long.class, java.lang.String.class
2218                    };
2219            private static final Class<?>[] _removeArticleLocaleParameterTypes40 = new Class[] {
2220                            long.class, java.lang.String.class
2221                    };
2222            private static final Class<?>[] _removeArticleLocaleParameterTypes41 = new Class[] {
2223                            long.class, java.lang.String.class, double.class,
2224                            java.lang.String.class
2225                    };
2226            private static final Class<?>[] _restoreArticleFromTrashParameterTypes42 = new Class[] {
2227                            long.class
2228                    };
2229            private static final Class<?>[] _restoreArticleFromTrashParameterTypes43 = new Class[] {
2230                            long.class, java.lang.String.class
2231                    };
2232            private static final Class<?>[] _searchParameterTypes44 = new Class[] {
2233                            long.class, long.class, int.class, int.class, int.class
2234                    };
2235            private static final Class<?>[] _searchParameterTypes45 = new Class[] {
2236                            long.class, long.class, java.util.List.class, long.class,
2237                            java.lang.String.class, java.lang.Double.class,
2238                            java.lang.String.class, java.lang.String.class,
2239                            java.lang.String.class, java.util.Date.class, java.util.Date.class,
2240                            int.class, java.util.Date.class, int.class, int.class,
2241                            com.liferay.portal.kernel.util.OrderByComparator.class
2242                    };
2243            private static final Class<?>[] _searchParameterTypes46 = new Class[] {
2244                            long.class, long.class, java.util.List.class, long.class,
2245                            java.lang.String.class, java.lang.Double.class,
2246                            java.lang.String.class, java.lang.String.class,
2247                            java.lang.String.class, java.lang.String.class,
2248                            java.lang.String.class, java.lang.String.class, java.util.Date.class,
2249                            java.util.Date.class, int.class, java.util.Date.class, boolean.class,
2250                            int.class, int.class,
2251                            com.liferay.portal.kernel.util.OrderByComparator.class
2252                    };
2253            private static final Class<?>[] _searchParameterTypes47 = new Class[] {
2254                            long.class, long.class, java.util.List.class, long.class,
2255                            java.lang.String.class, java.lang.Double.class,
2256                            java.lang.String.class, java.lang.String.class,
2257                            java.lang.String.class, java.lang.String.class,
2258                            java.lang.String[].class, java.lang.String[].class,
2259                            java.util.Date.class, java.util.Date.class, int.class,
2260                            java.util.Date.class, boolean.class, int.class, int.class,
2261                            com.liferay.portal.kernel.util.OrderByComparator.class
2262                    };
2263            private static final Class<?>[] _searchCountParameterTypes48 = new Class[] {
2264                            long.class, long.class, java.util.List.class, long.class,
2265                            java.lang.String.class, java.lang.Double.class,
2266                            java.lang.String.class, java.lang.String.class,
2267                            java.lang.String.class, java.util.Date.class, java.util.Date.class,
2268                            int.class, java.util.Date.class
2269                    };
2270            private static final Class<?>[] _searchCountParameterTypes49 = new Class[] {
2271                            long.class, long.class, java.util.List.class, long.class,
2272                            java.lang.String.class, java.lang.Double.class,
2273                            java.lang.String.class, java.lang.String.class,
2274                            java.lang.String.class, java.lang.String.class,
2275                            java.lang.String.class, java.lang.String.class, java.util.Date.class,
2276                            java.util.Date.class, int.class, java.util.Date.class, boolean.class
2277                    };
2278            private static final Class<?>[] _searchCountParameterTypes50 = new Class[] {
2279                            long.class, long.class, java.util.List.class, long.class,
2280                            java.lang.String.class, java.lang.Double.class,
2281                            java.lang.String.class, java.lang.String.class,
2282                            java.lang.String.class, java.lang.String.class,
2283                            java.lang.String[].class, java.lang.String[].class,
2284                            java.util.Date.class, java.util.Date.class, int.class,
2285                            java.util.Date.class, boolean.class
2286                    };
2287            private static final Class<?>[] _subscribeStructureParameterTypes51 = new Class[] {
2288                            long.class, long.class, long.class
2289                    };
2290            private static final Class<?>[] _unsubscribeStructureParameterTypes52 = new Class[] {
2291                            long.class, long.class, long.class
2292                    };
2293            private static final Class<?>[] _updateArticleParameterTypes53 = new Class[] {
2294                            long.class, long.class, long.class, java.lang.String.class,
2295                            double.class, java.util.Map.class, java.util.Map.class,
2296                            java.lang.String.class, java.lang.String.class,
2297                            com.liferay.portal.service.ServiceContext.class
2298                    };
2299            private static final Class<?>[] _updateArticleParameterTypes54 = new Class[] {
2300                            long.class, long.class, java.lang.String.class, double.class,
2301                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2302                            java.lang.String.class, java.lang.String.class,
2303                            java.lang.String.class, java.lang.String.class, int.class, int.class,
2304                            int.class, int.class, int.class, int.class, int.class, int.class,
2305                            int.class, int.class, boolean.class, int.class, int.class, int.class,
2306                            int.class, int.class, boolean.class, boolean.class, boolean.class,
2307                            java.lang.String.class, java.io.File.class, java.util.Map.class,
2308                            java.lang.String.class,
2309                            com.liferay.portal.service.ServiceContext.class
2310                    };
2311            private static final Class<?>[] _updateArticleParameterTypes55 = new Class[] {
2312                            long.class, long.class, java.lang.String.class, double.class,
2313                            java.lang.String.class,
2314                            com.liferay.portal.service.ServiceContext.class
2315                    };
2316            private static final Class<?>[] _updateArticleTranslationParameterTypes56 = new Class[] {
2317                            long.class, java.lang.String.class, double.class,
2318                            java.util.Locale.class, java.lang.String.class,
2319                            java.lang.String.class, java.lang.String.class, java.util.Map.class
2320                    };
2321            private static final Class<?>[] _updateArticleTranslationParameterTypes57 = new Class[] {
2322                            long.class, java.lang.String.class, double.class,
2323                            java.util.Locale.class, java.lang.String.class,
2324                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2325                            com.liferay.portal.service.ServiceContext.class
2326                    };
2327            private static final Class<?>[] _updateContentParameterTypes58 = new Class[] {
2328                            long.class, java.lang.String.class, double.class,
2329                            java.lang.String.class
2330                    };
2331            private static final Class<?>[] _updateStatusParameterTypes59 = new Class[] {
2332                            long.class, java.lang.String.class, double.class, int.class,
2333                            java.lang.String.class,
2334                            com.liferay.portal.service.ServiceContext.class
2335                    };
2336    }