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 ddmStructureKey,
065                    java.lang.String ddmTemplateKey, java.lang.String layoutUuid,
066                    int displayDateMonth, int displayDateDay, int displayDateYear,
067                    int displayDateHour, int displayDateMinute, int expirationDateMonth,
068                    int expirationDateDay, int expirationDateYear, int expirationDateHour,
069                    int expirationDateMinute, boolean neverExpire, int reviewDateMonth,
070                    int reviewDateDay, int reviewDateYear, int reviewDateHour,
071                    int reviewDateMinute, boolean neverReview, boolean indexable,
072                    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, 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 ddmStructureKey,
122                    java.lang.String ddmTemplateKey, java.lang.String layoutUuid,
123                    int displayDateMonth, int displayDateDay, int displayDateYear,
124                    int displayDateHour, int displayDateMinute, int expirationDateMonth,
125                    int expirationDateDay, int expirationDateYear, int expirationDateHour,
126                    int expirationDateMinute, boolean neverExpire, int reviewDateMonth,
127                    int reviewDateDay, int reviewDateYear, int reviewDateHour,
128                    int reviewDateMinute, boolean neverReview, boolean indexable,
129                    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, 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 ddmStructureKey, java.lang.String ddmTemplateKey,
1520                    java.util.Date displayDateGT, java.util.Date displayDateLT, int status,
1521                    java.util.Date reviewDate, int start, int end,
1522                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1523                    try {
1524                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1525                                            "search", _searchParameterTypes45);
1526    
1527                            MethodHandler methodHandler = new MethodHandler(methodKey,
1528                                            companyId, groupId, folderIds, classNameId, keywords,
1529                                            version, ddmStructureKey, ddmTemplateKey, displayDateGT,
1530                                            displayDateLT, status, reviewDate, start, end, obc);
1531    
1532                            Object returnObj = null;
1533    
1534                            try {
1535                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1536                            }
1537                            catch (Exception e) {
1538                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1539                            }
1540    
1541                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1542                    }
1543                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1544                            _log.error(se, se);
1545    
1546                            throw se;
1547                    }
1548            }
1549    
1550            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1551                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1552                    java.util.List<java.lang.Long> folderIds, long classNameId,
1553                    java.lang.String articleId, java.lang.Double version,
1554                    java.lang.String title, java.lang.String description,
1555                    java.lang.String content, java.lang.String ddmStructureKey,
1556                    java.lang.String ddmTemplateKey, java.util.Date displayDateGT,
1557                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1558                    boolean andOperator, int start, int end,
1559                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1560                    try {
1561                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1562                                            "search", _searchParameterTypes46);
1563    
1564                            MethodHandler methodHandler = new MethodHandler(methodKey,
1565                                            companyId, groupId, folderIds, classNameId, articleId,
1566                                            version, title, description, content, ddmStructureKey,
1567                                            ddmTemplateKey, displayDateGT, displayDateLT, status,
1568                                            reviewDate, andOperator, start, end, obc);
1569    
1570                            Object returnObj = null;
1571    
1572                            try {
1573                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1574                            }
1575                            catch (Exception e) {
1576                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1577                            }
1578    
1579                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1580                    }
1581                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1582                            _log.error(se, se);
1583    
1584                            throw se;
1585                    }
1586            }
1587    
1588            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1589                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1590                    java.util.List<java.lang.Long> folderIds, long classNameId,
1591                    java.lang.String articleId, java.lang.Double version,
1592                    java.lang.String title, java.lang.String description,
1593                    java.lang.String content, java.lang.String[] ddmStructureKeys,
1594                    java.lang.String[] ddmTemplateKeys, java.util.Date displayDateGT,
1595                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1596                    boolean andOperator, int start, int end,
1597                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1598                    try {
1599                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1600                                            "search", _searchParameterTypes47);
1601    
1602                            MethodHandler methodHandler = new MethodHandler(methodKey,
1603                                            companyId, groupId, folderIds, classNameId, articleId,
1604                                            version, title, description, content, ddmStructureKeys,
1605                                            ddmTemplateKeys, displayDateGT, displayDateLT, status,
1606                                            reviewDate, andOperator, start, end, obc);
1607    
1608                            Object returnObj = null;
1609    
1610                            try {
1611                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1612                            }
1613                            catch (Exception e) {
1614                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1615                            }
1616    
1617                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1618                    }
1619                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1620                            _log.error(se, se);
1621    
1622                            throw se;
1623                    }
1624            }
1625    
1626            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1627                    long groupId, java.util.List<java.lang.Long> folderIds,
1628                    long classNameId, java.lang.String keywords, java.lang.Double version,
1629                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
1630                    java.util.Date displayDateGT, java.util.Date displayDateLT, int status,
1631                    java.util.Date reviewDate) {
1632                    try {
1633                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1634                                            "searchCount", _searchCountParameterTypes48);
1635    
1636                            MethodHandler methodHandler = new MethodHandler(methodKey,
1637                                            companyId, groupId, folderIds, classNameId, keywords,
1638                                            version, ddmStructureKey, ddmTemplateKey, displayDateGT,
1639                                            displayDateLT, status, reviewDate);
1640    
1641                            Object returnObj = null;
1642    
1643                            try {
1644                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1645                            }
1646                            catch (Exception e) {
1647                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1648                            }
1649    
1650                            return ((Integer)returnObj).intValue();
1651                    }
1652                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1653                            _log.error(se, se);
1654    
1655                            throw se;
1656                    }
1657            }
1658    
1659            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1660                    long groupId, java.util.List<java.lang.Long> folderIds,
1661                    long classNameId, java.lang.String articleId, java.lang.Double version,
1662                    java.lang.String title, java.lang.String description,
1663                    java.lang.String content, java.lang.String ddmStructureKey,
1664                    java.lang.String ddmTemplateKey, java.util.Date displayDateGT,
1665                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1666                    boolean andOperator) {
1667                    try {
1668                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1669                                            "searchCount", _searchCountParameterTypes49);
1670    
1671                            MethodHandler methodHandler = new MethodHandler(methodKey,
1672                                            companyId, groupId, folderIds, classNameId, articleId,
1673                                            version, title, description, content, ddmStructureKey,
1674                                            ddmTemplateKey, displayDateGT, displayDateLT, status,
1675                                            reviewDate, andOperator);
1676    
1677                            Object returnObj = null;
1678    
1679                            try {
1680                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1681                            }
1682                            catch (Exception e) {
1683                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1684                            }
1685    
1686                            return ((Integer)returnObj).intValue();
1687                    }
1688                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1689                            _log.error(se, se);
1690    
1691                            throw se;
1692                    }
1693            }
1694    
1695            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1696                    long groupId, java.util.List<java.lang.Long> folderIds,
1697                    long classNameId, java.lang.String articleId, java.lang.Double version,
1698                    java.lang.String title, java.lang.String description,
1699                    java.lang.String content, java.lang.String[] ddmStructureKeys,
1700                    java.lang.String[] ddmTemplateKeys, java.util.Date displayDateGT,
1701                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1702                    boolean andOperator) {
1703                    try {
1704                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1705                                            "searchCount", _searchCountParameterTypes50);
1706    
1707                            MethodHandler methodHandler = new MethodHandler(methodKey,
1708                                            companyId, groupId, folderIds, classNameId, articleId,
1709                                            version, title, description, content, ddmStructureKeys,
1710                                            ddmTemplateKeys, displayDateGT, displayDateLT, status,
1711                                            reviewDate, andOperator);
1712    
1713                            Object returnObj = null;
1714    
1715                            try {
1716                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1717                            }
1718                            catch (Exception e) {
1719                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1720                            }
1721    
1722                            return ((Integer)returnObj).intValue();
1723                    }
1724                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1725                            _log.error(se, se);
1726    
1727                            throw se;
1728                    }
1729            }
1730    
1731            public static void subscribeStructure(HttpPrincipal httpPrincipal,
1732                    long groupId, long userId, long ddmStructureId)
1733                    throws com.liferay.portal.kernel.exception.PortalException {
1734                    try {
1735                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1736                                            "subscribeStructure", _subscribeStructureParameterTypes51);
1737    
1738                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1739                                            userId, ddmStructureId);
1740    
1741                            try {
1742                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1743                            }
1744                            catch (Exception e) {
1745                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1746                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1747                                    }
1748    
1749                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1750                            }
1751                    }
1752                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1753                            _log.error(se, se);
1754    
1755                            throw se;
1756                    }
1757            }
1758    
1759            public static void unsubscribeStructure(HttpPrincipal httpPrincipal,
1760                    long groupId, long userId, long ddmStructureId)
1761                    throws com.liferay.portal.kernel.exception.PortalException {
1762                    try {
1763                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1764                                            "unsubscribeStructure",
1765                                            _unsubscribeStructureParameterTypes52);
1766    
1767                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1768                                            userId, ddmStructureId);
1769    
1770                            try {
1771                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1772                            }
1773                            catch (Exception e) {
1774                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1775                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1776                                    }
1777    
1778                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1779                            }
1780                    }
1781                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1782                            _log.error(se, se);
1783    
1784                            throw se;
1785                    }
1786            }
1787    
1788            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1789                    HttpPrincipal httpPrincipal, long userId, long groupId, long folderId,
1790                    java.lang.String articleId, double version,
1791                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1792                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1793                    java.lang.String content, java.lang.String layoutUuid,
1794                    com.liferay.portal.service.ServiceContext serviceContext)
1795                    throws com.liferay.portal.kernel.exception.PortalException {
1796                    try {
1797                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1798                                            "updateArticle", _updateArticleParameterTypes53);
1799    
1800                            MethodHandler methodHandler = new MethodHandler(methodKey, userId,
1801                                            groupId, folderId, articleId, version, titleMap,
1802                                            descriptionMap, content, layoutUuid, serviceContext);
1803    
1804                            Object returnObj = null;
1805    
1806                            try {
1807                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1808                            }
1809                            catch (Exception e) {
1810                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1811                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1812                                    }
1813    
1814                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1815                            }
1816    
1817                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1818                    }
1819                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1820                            _log.error(se, se);
1821    
1822                            throw se;
1823                    }
1824            }
1825    
1826            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1827                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1828                    java.lang.String articleId, double version,
1829                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1830                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1831                    java.lang.String content, java.lang.String ddmStructureKey,
1832                    java.lang.String ddmTemplateKey, java.lang.String layoutUuid,
1833                    int displayDateMonth, int displayDateDay, int displayDateYear,
1834                    int displayDateHour, int displayDateMinute, int expirationDateMonth,
1835                    int expirationDateDay, int expirationDateYear, int expirationDateHour,
1836                    int expirationDateMinute, boolean neverExpire, int reviewDateMonth,
1837                    int reviewDateDay, int reviewDateYear, int reviewDateHour,
1838                    int reviewDateMinute, boolean neverReview, boolean indexable,
1839                    boolean smallImage, java.lang.String smallImageURL,
1840                    java.io.File smallFile, java.util.Map<java.lang.String, byte[]> images,
1841                    java.lang.String articleURL,
1842                    com.liferay.portal.service.ServiceContext serviceContext)
1843                    throws com.liferay.portal.kernel.exception.PortalException {
1844                    try {
1845                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1846                                            "updateArticle", _updateArticleParameterTypes54);
1847    
1848                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1849                                            folderId, articleId, version, titleMap, descriptionMap,
1850                                            content, ddmStructureKey, ddmTemplateKey, layoutUuid,
1851                                            displayDateMonth, displayDateDay, displayDateYear,
1852                                            displayDateHour, displayDateMinute, expirationDateMonth,
1853                                            expirationDateDay, expirationDateYear, expirationDateHour,
1854                                            expirationDateMinute, neverExpire, reviewDateMonth,
1855                                            reviewDateDay, reviewDateYear, reviewDateHour,
1856                                            reviewDateMinute, neverReview, indexable, smallImage,
1857                                            smallImageURL, smallFile, images, articleURL, serviceContext);
1858    
1859                            Object returnObj = null;
1860    
1861                            try {
1862                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1863                            }
1864                            catch (Exception e) {
1865                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1866                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1867                                    }
1868    
1869                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1870                            }
1871    
1872                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1873                    }
1874                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1875                            _log.error(se, se);
1876    
1877                            throw se;
1878                    }
1879            }
1880    
1881            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1882                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1883                    java.lang.String articleId, double version, java.lang.String content,
1884                    com.liferay.portal.service.ServiceContext serviceContext)
1885                    throws com.liferay.portal.kernel.exception.PortalException {
1886                    try {
1887                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1888                                            "updateArticle", _updateArticleParameterTypes55);
1889    
1890                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1891                                            folderId, articleId, version, content, serviceContext);
1892    
1893                            Object returnObj = null;
1894    
1895                            try {
1896                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1897                            }
1898                            catch (Exception e) {
1899                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1900                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1901                                    }
1902    
1903                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1904                            }
1905    
1906                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1907                    }
1908                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1909                            _log.error(se, se);
1910    
1911                            throw se;
1912                    }
1913            }
1914    
1915            public static com.liferay.portlet.journal.model.JournalArticle updateArticleTranslation(
1916                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1917                    double version, java.util.Locale locale, java.lang.String title,
1918                    java.lang.String description, java.lang.String content,
1919                    java.util.Map<java.lang.String, byte[]> images)
1920                    throws com.liferay.portal.kernel.exception.PortalException {
1921                    try {
1922                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1923                                            "updateArticleTranslation",
1924                                            _updateArticleTranslationParameterTypes56);
1925    
1926                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1927                                            articleId, version, locale, title, description, content,
1928                                            images);
1929    
1930                            Object returnObj = null;
1931    
1932                            try {
1933                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1934                            }
1935                            catch (Exception e) {
1936                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1937                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1938                                    }
1939    
1940                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1941                            }
1942    
1943                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1944                    }
1945                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1946                            _log.error(se, se);
1947    
1948                            throw se;
1949                    }
1950            }
1951    
1952            public static com.liferay.portlet.journal.model.JournalArticle updateArticleTranslation(
1953                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1954                    double version, java.util.Locale locale, java.lang.String title,
1955                    java.lang.String description, java.lang.String content,
1956                    java.util.Map<java.lang.String, byte[]> images,
1957                    com.liferay.portal.service.ServiceContext serviceContext)
1958                    throws com.liferay.portal.kernel.exception.PortalException {
1959                    try {
1960                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1961                                            "updateArticleTranslation",
1962                                            _updateArticleTranslationParameterTypes57);
1963    
1964                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1965                                            articleId, version, locale, title, description, content,
1966                                            images, serviceContext);
1967    
1968                            Object returnObj = null;
1969    
1970                            try {
1971                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1972                            }
1973                            catch (Exception e) {
1974                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1975                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1976                                    }
1977    
1978                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1979                            }
1980    
1981                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1982                    }
1983                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1984                            _log.error(se, se);
1985    
1986                            throw se;
1987                    }
1988            }
1989    
1990            public static com.liferay.portlet.journal.model.JournalArticle updateContent(
1991                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1992                    double version, java.lang.String content)
1993                    throws com.liferay.portal.kernel.exception.PortalException {
1994                    try {
1995                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1996                                            "updateContent", _updateContentParameterTypes58);
1997    
1998                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1999                                            articleId, version, content);
2000    
2001                            Object returnObj = null;
2002    
2003                            try {
2004                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2005                            }
2006                            catch (Exception e) {
2007                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2008                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2009                                    }
2010    
2011                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2012                            }
2013    
2014                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2015                    }
2016                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2017                            _log.error(se, se);
2018    
2019                            throw se;
2020                    }
2021            }
2022    
2023            public static com.liferay.portlet.journal.model.JournalArticle updateStatus(
2024                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
2025                    double version, int status, java.lang.String articleURL,
2026                    com.liferay.portal.service.ServiceContext serviceContext)
2027                    throws com.liferay.portal.kernel.exception.PortalException {
2028                    try {
2029                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
2030                                            "updateStatus", _updateStatusParameterTypes59);
2031    
2032                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2033                                            articleId, version, status, articleURL, serviceContext);
2034    
2035                            Object returnObj = null;
2036    
2037                            try {
2038                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2039                            }
2040                            catch (Exception e) {
2041                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2042                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2043                                    }
2044    
2045                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2046                            }
2047    
2048                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2049                    }
2050                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2051                            _log.error(se, se);
2052    
2053                            throw se;
2054                    }
2055            }
2056    
2057            private static Log _log = LogFactoryUtil.getLog(JournalArticleServiceHttp.class);
2058            private static final Class<?>[] _addArticleParameterTypes0 = new Class[] {
2059                            long.class, long.class, long.class, long.class,
2060                            java.lang.String.class, boolean.class, java.util.Map.class,
2061                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2062                            java.lang.String.class, java.lang.String.class, int.class, int.class,
2063                            int.class, int.class, int.class, int.class, int.class, int.class,
2064                            int.class, int.class, boolean.class, int.class, int.class, int.class,
2065                            int.class, int.class, boolean.class, boolean.class, boolean.class,
2066                            java.lang.String.class, java.io.File.class, java.util.Map.class,
2067                            java.lang.String.class,
2068                            com.liferay.portal.service.ServiceContext.class
2069                    };
2070            private static final Class<?>[] _addArticleParameterTypes1 = new Class[] {
2071                            long.class, long.class, long.class, long.class,
2072                            java.lang.String.class, boolean.class, java.util.Map.class,
2073                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2074                            java.lang.String.class, java.lang.String.class, int.class, int.class,
2075                            int.class, int.class, int.class, int.class, int.class, int.class,
2076                            int.class, int.class, boolean.class, int.class, int.class, int.class,
2077                            int.class, int.class, boolean.class, boolean.class,
2078                            java.lang.String.class,
2079                            com.liferay.portal.service.ServiceContext.class
2080                    };
2081            private static final Class<?>[] _copyArticleParameterTypes2 = new Class[] {
2082                            long.class, java.lang.String.class, java.lang.String.class,
2083                            boolean.class, double.class
2084                    };
2085            private static final Class<?>[] _deleteArticleParameterTypes3 = new Class[] {
2086                            long.class, java.lang.String.class, double.class,
2087                            java.lang.String.class,
2088                            com.liferay.portal.service.ServiceContext.class
2089                    };
2090            private static final Class<?>[] _deleteArticleParameterTypes4 = new Class[] {
2091                            long.class, java.lang.String.class, java.lang.String.class,
2092                            com.liferay.portal.service.ServiceContext.class
2093                    };
2094            private static final Class<?>[] _expireArticleParameterTypes5 = new Class[] {
2095                            long.class, java.lang.String.class, double.class,
2096                            java.lang.String.class,
2097                            com.liferay.portal.service.ServiceContext.class
2098                    };
2099            private static final Class<?>[] _expireArticleParameterTypes6 = new Class[] {
2100                            long.class, java.lang.String.class, java.lang.String.class,
2101                            com.liferay.portal.service.ServiceContext.class
2102                    };
2103            private static final Class<?>[] _getArticleParameterTypes7 = new Class[] {
2104                            long.class
2105                    };
2106            private static final Class<?>[] _getArticleParameterTypes8 = new Class[] {
2107                            long.class, java.lang.String.class
2108                    };
2109            private static final Class<?>[] _getArticleParameterTypes9 = new Class[] {
2110                            long.class, java.lang.String.class, double.class
2111                    };
2112            private static final Class<?>[] _getArticleParameterTypes10 = new Class[] {
2113                            long.class, java.lang.String.class, long.class
2114                    };
2115            private static final Class<?>[] _getArticleByUrlTitleParameterTypes11 = new Class[] {
2116                            long.class, java.lang.String.class
2117                    };
2118            private static final Class<?>[] _getArticleContentParameterTypes12 = new Class[] {
2119                            long.class, java.lang.String.class, double.class,
2120                            java.lang.String.class,
2121                            com.liferay.portal.kernel.portlet.PortletRequestModel.class,
2122                            com.liferay.portal.theme.ThemeDisplay.class
2123                    };
2124            private static final Class<?>[] _getArticleContentParameterTypes13 = new Class[] {
2125                            long.class, java.lang.String.class, double.class,
2126                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
2127                    };
2128            private static final Class<?>[] _getArticleContentParameterTypes14 = new Class[] {
2129                            long.class, java.lang.String.class, java.lang.String.class,
2130                            com.liferay.portal.kernel.portlet.PortletRequestModel.class,
2131                            com.liferay.portal.theme.ThemeDisplay.class
2132                    };
2133            private static final Class<?>[] _getArticleContentParameterTypes15 = new Class[] {
2134                            long.class, java.lang.String.class, java.lang.String.class,
2135                            com.liferay.portal.theme.ThemeDisplay.class
2136                    };
2137            private static final Class<?>[] _getArticlesParameterTypes16 = new Class[] {
2138                            long.class, long.class
2139                    };
2140            private static final Class<?>[] _getArticlesParameterTypes17 = new Class[] {
2141                            long.class, long.class, int.class, int.class,
2142                            com.liferay.portal.kernel.util.OrderByComparator.class
2143                    };
2144            private static final Class<?>[] _getArticlesByArticleIdParameterTypes18 = new Class[] {
2145                            long.class, java.lang.String.class, int.class, int.class,
2146                            com.liferay.portal.kernel.util.OrderByComparator.class
2147                    };
2148            private static final Class<?>[] _getArticlesByLayoutUuidParameterTypes19 = new Class[] {
2149                            long.class, java.lang.String.class
2150                    };
2151            private static final Class<?>[] _getArticlesByStructureIdParameterTypes20 = new Class[] {
2152                            long.class, long.class, java.lang.String.class, int.class, int.class,
2153                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
2154                    };
2155            private static final Class<?>[] _getArticlesByStructureIdParameterTypes21 = new Class[] {
2156                            long.class, java.lang.String.class, int.class, int.class,
2157                            com.liferay.portal.kernel.util.OrderByComparator.class
2158                    };
2159            private static final Class<?>[] _getArticlesCountParameterTypes22 = new Class[] {
2160                            long.class, long.class
2161                    };
2162            private static final Class<?>[] _getArticlesCountParameterTypes23 = new Class[] {
2163                            long.class, long.class, int.class
2164                    };
2165            private static final Class<?>[] _getArticlesCountByArticleIdParameterTypes24 =
2166                    new Class[] { long.class, java.lang.String.class };
2167            private static final Class<?>[] _getArticlesCountByStructureIdParameterTypes25 =
2168                    new Class[] { long.class, long.class, java.lang.String.class, int.class };
2169            private static final Class<?>[] _getArticlesCountByStructureIdParameterTypes26 =
2170                    new Class[] { long.class, java.lang.String.class };
2171            private static final Class<?>[] _getDisplayArticleByUrlTitleParameterTypes27 =
2172                    new Class[] { long.class, java.lang.String.class };
2173            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes28 = new Class[] {
2174                            long.class, java.util.List.class
2175                    };
2176            private static final Class<?>[] _getGroupArticlesParameterTypes29 = new Class[] {
2177                            long.class, long.class, long.class, int.class, int.class, int.class,
2178                            com.liferay.portal.kernel.util.OrderByComparator.class
2179                    };
2180            private static final Class<?>[] _getGroupArticlesParameterTypes30 = new Class[] {
2181                            long.class, long.class, long.class, int.class, int.class,
2182                            com.liferay.portal.kernel.util.OrderByComparator.class
2183                    };
2184            private static final Class<?>[] _getGroupArticlesCountParameterTypes31 = new Class[] {
2185                            long.class, long.class, long.class
2186                    };
2187            private static final Class<?>[] _getGroupArticlesCountParameterTypes32 = new Class[] {
2188                            long.class, long.class, long.class, int.class
2189                    };
2190            private static final Class<?>[] _getLatestArticleParameterTypes33 = new Class[] {
2191                            long.class
2192                    };
2193            private static final Class<?>[] _getLatestArticleParameterTypes34 = new Class[] {
2194                            long.class, java.lang.String.class, int.class
2195                    };
2196            private static final Class<?>[] _getLatestArticleParameterTypes35 = new Class[] {
2197                            long.class, java.lang.String.class, long.class
2198                    };
2199            private static final Class<?>[] _moveArticleParameterTypes36 = new Class[] {
2200                            long.class, java.lang.String.class, long.class
2201                    };
2202            private static final Class<?>[] _moveArticleFromTrashParameterTypes37 = new Class[] {
2203                            long.class, long.class, long.class,
2204                            com.liferay.portal.service.ServiceContext.class
2205                    };
2206            private static final Class<?>[] _moveArticleFromTrashParameterTypes38 = new Class[] {
2207                            long.class, java.lang.String.class, long.class,
2208                            com.liferay.portal.service.ServiceContext.class
2209                    };
2210            private static final Class<?>[] _moveArticleToTrashParameterTypes39 = new Class[] {
2211                            long.class, java.lang.String.class
2212                    };
2213            private static final Class<?>[] _removeArticleLocaleParameterTypes40 = new Class[] {
2214                            long.class, java.lang.String.class
2215                    };
2216            private static final Class<?>[] _removeArticleLocaleParameterTypes41 = new Class[] {
2217                            long.class, java.lang.String.class, double.class,
2218                            java.lang.String.class
2219                    };
2220            private static final Class<?>[] _restoreArticleFromTrashParameterTypes42 = new Class[] {
2221                            long.class
2222                    };
2223            private static final Class<?>[] _restoreArticleFromTrashParameterTypes43 = new Class[] {
2224                            long.class, java.lang.String.class
2225                    };
2226            private static final Class<?>[] _searchParameterTypes44 = new Class[] {
2227                            long.class, long.class, int.class, int.class, int.class
2228                    };
2229            private static final Class<?>[] _searchParameterTypes45 = new Class[] {
2230                            long.class, long.class, java.util.List.class, long.class,
2231                            java.lang.String.class, java.lang.Double.class,
2232                            java.lang.String.class, java.lang.String.class, java.util.Date.class,
2233                            java.util.Date.class, int.class, java.util.Date.class, int.class,
2234                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
2235                    };
2236            private static final Class<?>[] _searchParameterTypes46 = new Class[] {
2237                            long.class, long.class, java.util.List.class, long.class,
2238                            java.lang.String.class, java.lang.Double.class,
2239                            java.lang.String.class, java.lang.String.class,
2240                            java.lang.String.class, java.lang.String.class,
2241                            java.lang.String.class, java.util.Date.class, java.util.Date.class,
2242                            int.class, java.util.Date.class, boolean.class, int.class, int.class,
2243                            com.liferay.portal.kernel.util.OrderByComparator.class
2244                    };
2245            private static final Class<?>[] _searchParameterTypes47 = new Class[] {
2246                            long.class, long.class, java.util.List.class, long.class,
2247                            java.lang.String.class, java.lang.Double.class,
2248                            java.lang.String.class, java.lang.String.class,
2249                            java.lang.String.class, java.lang.String[].class,
2250                            java.lang.String[].class, java.util.Date.class, java.util.Date.class,
2251                            int.class, java.util.Date.class, boolean.class, int.class, int.class,
2252                            com.liferay.portal.kernel.util.OrderByComparator.class
2253                    };
2254            private static final Class<?>[] _searchCountParameterTypes48 = new Class[] {
2255                            long.class, long.class, java.util.List.class, long.class,
2256                            java.lang.String.class, java.lang.Double.class,
2257                            java.lang.String.class, java.lang.String.class, java.util.Date.class,
2258                            java.util.Date.class, int.class, java.util.Date.class
2259                    };
2260            private static final Class<?>[] _searchCountParameterTypes49 = new Class[] {
2261                            long.class, long.class, java.util.List.class, long.class,
2262                            java.lang.String.class, java.lang.Double.class,
2263                            java.lang.String.class, java.lang.String.class,
2264                            java.lang.String.class, java.lang.String.class,
2265                            java.lang.String.class, java.util.Date.class, java.util.Date.class,
2266                            int.class, java.util.Date.class, boolean.class
2267                    };
2268            private static final Class<?>[] _searchCountParameterTypes50 = new Class[] {
2269                            long.class, long.class, java.util.List.class, long.class,
2270                            java.lang.String.class, java.lang.Double.class,
2271                            java.lang.String.class, java.lang.String.class,
2272                            java.lang.String.class, java.lang.String[].class,
2273                            java.lang.String[].class, java.util.Date.class, java.util.Date.class,
2274                            int.class, java.util.Date.class, boolean.class
2275                    };
2276            private static final Class<?>[] _subscribeStructureParameterTypes51 = new Class[] {
2277                            long.class, long.class, long.class
2278                    };
2279            private static final Class<?>[] _unsubscribeStructureParameterTypes52 = new Class[] {
2280                            long.class, long.class, long.class
2281                    };
2282            private static final Class<?>[] _updateArticleParameterTypes53 = new Class[] {
2283                            long.class, long.class, long.class, java.lang.String.class,
2284                            double.class, java.util.Map.class, java.util.Map.class,
2285                            java.lang.String.class, java.lang.String.class,
2286                            com.liferay.portal.service.ServiceContext.class
2287                    };
2288            private static final Class<?>[] _updateArticleParameterTypes54 = new Class[] {
2289                            long.class, long.class, java.lang.String.class, double.class,
2290                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2291                            java.lang.String.class, java.lang.String.class,
2292                            java.lang.String.class, int.class, int.class, int.class, int.class,
2293                            int.class, int.class, int.class, int.class, int.class, int.class,
2294                            boolean.class, int.class, int.class, int.class, int.class, int.class,
2295                            boolean.class, boolean.class, boolean.class, java.lang.String.class,
2296                            java.io.File.class, java.util.Map.class, java.lang.String.class,
2297                            com.liferay.portal.service.ServiceContext.class
2298                    };
2299            private static final Class<?>[] _updateArticleParameterTypes55 = new Class[] {
2300                            long.class, long.class, java.lang.String.class, double.class,
2301                            java.lang.String.class,
2302                            com.liferay.portal.service.ServiceContext.class
2303                    };
2304            private static final Class<?>[] _updateArticleTranslationParameterTypes56 = new Class[] {
2305                            long.class, java.lang.String.class, double.class,
2306                            java.util.Locale.class, java.lang.String.class,
2307                            java.lang.String.class, java.lang.String.class, java.util.Map.class
2308                    };
2309            private static final Class<?>[] _updateArticleTranslationParameterTypes57 = new Class[] {
2310                            long.class, java.lang.String.class, double.class,
2311                            java.util.Locale.class, java.lang.String.class,
2312                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2313                            com.liferay.portal.service.ServiceContext.class
2314                    };
2315            private static final Class<?>[] _updateContentParameterTypes58 = new Class[] {
2316                            long.class, java.lang.String.class, double.class,
2317                            java.lang.String.class
2318                    };
2319            private static final Class<?>[] _updateStatusParameterTypes59 = new Class[] {
2320                            long.class, java.lang.String.class, double.class, int.class,
2321                            java.lang.String.class,
2322                            com.liferay.portal.service.ServiceContext.class
2323                    };
2324    }