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 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 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 HttpPrincipal
053     * @see 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 fetchArticle(
327                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId)
328                    throws com.liferay.portal.kernel.exception.PortalException {
329                    try {
330                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
331                                            "fetchArticle", _fetchArticleParameterTypes7);
332    
333                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
334                                            articleId);
335    
336                            Object returnObj = null;
337    
338                            try {
339                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
340                            }
341                            catch (Exception e) {
342                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
343                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
344                                    }
345    
346                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
347                            }
348    
349                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
350                    }
351                    catch (com.liferay.portal.kernel.exception.SystemException se) {
352                            _log.error(se, se);
353    
354                            throw se;
355                    }
356            }
357    
358            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
359                    HttpPrincipal httpPrincipal, long id)
360                    throws com.liferay.portal.kernel.exception.PortalException {
361                    try {
362                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
363                                            "getArticle", _getArticleParameterTypes8);
364    
365                            MethodHandler methodHandler = new MethodHandler(methodKey, id);
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                    throws com.liferay.portal.kernel.exception.PortalException {
392                    try {
393                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
394                                            "getArticle", _getArticleParameterTypes9);
395    
396                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
397                                            articleId);
398    
399                            Object returnObj = null;
400    
401                            try {
402                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
403                            }
404                            catch (Exception e) {
405                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
406                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
407                                    }
408    
409                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
410                            }
411    
412                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
413                    }
414                    catch (com.liferay.portal.kernel.exception.SystemException se) {
415                            _log.error(se, se);
416    
417                            throw se;
418                    }
419            }
420    
421            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
422                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
423                    double version)
424                    throws com.liferay.portal.kernel.exception.PortalException {
425                    try {
426                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
427                                            "getArticle", _getArticleParameterTypes10);
428    
429                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
430                                            articleId, version);
431    
432                            Object returnObj = null;
433    
434                            try {
435                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
436                            }
437                            catch (Exception e) {
438                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
439                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
440                                    }
441    
442                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
443                            }
444    
445                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
446                    }
447                    catch (com.liferay.portal.kernel.exception.SystemException se) {
448                            _log.error(se, se);
449    
450                            throw se;
451                    }
452            }
453    
454            public static com.liferay.portlet.journal.model.JournalArticle getArticle(
455                    HttpPrincipal httpPrincipal, long groupId, java.lang.String className,
456                    long classPK)
457                    throws com.liferay.portal.kernel.exception.PortalException {
458                    try {
459                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
460                                            "getArticle", _getArticleParameterTypes11);
461    
462                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
463                                            className, classPK);
464    
465                            Object returnObj = null;
466    
467                            try {
468                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
469                            }
470                            catch (Exception e) {
471                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
472                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
473                                    }
474    
475                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
476                            }
477    
478                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
479                    }
480                    catch (com.liferay.portal.kernel.exception.SystemException se) {
481                            _log.error(se, se);
482    
483                            throw se;
484                    }
485            }
486    
487            public static com.liferay.portlet.journal.model.JournalArticle getArticleByUrlTitle(
488                    HttpPrincipal httpPrincipal, long groupId, java.lang.String urlTitle)
489                    throws com.liferay.portal.kernel.exception.PortalException {
490                    try {
491                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
492                                            "getArticleByUrlTitle",
493                                            _getArticleByUrlTitleParameterTypes12);
494    
495                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
496                                            urlTitle);
497    
498                            Object returnObj = null;
499    
500                            try {
501                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
502                            }
503                            catch (Exception e) {
504                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
505                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
506                                    }
507    
508                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
509                            }
510    
511                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
512                    }
513                    catch (com.liferay.portal.kernel.exception.SystemException se) {
514                            _log.error(se, se);
515    
516                            throw se;
517                    }
518            }
519    
520            public static java.lang.String getArticleContent(
521                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
522                    double version, java.lang.String languageId,
523                    com.liferay.portal.kernel.portlet.PortletRequestModel portletRequestModel,
524                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
525                    throws com.liferay.portal.kernel.exception.PortalException {
526                    try {
527                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
528                                            "getArticleContent", _getArticleContentParameterTypes13);
529    
530                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
531                                            articleId, version, languageId, portletRequestModel,
532                                            themeDisplay);
533    
534                            Object returnObj = null;
535    
536                            try {
537                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
538                            }
539                            catch (Exception e) {
540                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
541                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
542                                    }
543    
544                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
545                            }
546    
547                            return (java.lang.String)returnObj;
548                    }
549                    catch (com.liferay.portal.kernel.exception.SystemException se) {
550                            _log.error(se, se);
551    
552                            throw se;
553                    }
554            }
555    
556            public static java.lang.String getArticleContent(
557                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
558                    double version, java.lang.String languageId,
559                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
560                    throws com.liferay.portal.kernel.exception.PortalException {
561                    try {
562                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
563                                            "getArticleContent", _getArticleContentParameterTypes14);
564    
565                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
566                                            articleId, version, languageId, themeDisplay);
567    
568                            Object returnObj = null;
569    
570                            try {
571                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
572                            }
573                            catch (Exception e) {
574                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
575                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
576                                    }
577    
578                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
579                            }
580    
581                            return (java.lang.String)returnObj;
582                    }
583                    catch (com.liferay.portal.kernel.exception.SystemException se) {
584                            _log.error(se, se);
585    
586                            throw se;
587                    }
588            }
589    
590            public static java.lang.String getArticleContent(
591                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
592                    java.lang.String languageId,
593                    com.liferay.portal.kernel.portlet.PortletRequestModel portletRequestModel,
594                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
595                    throws com.liferay.portal.kernel.exception.PortalException {
596                    try {
597                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
598                                            "getArticleContent", _getArticleContentParameterTypes15);
599    
600                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
601                                            articleId, languageId, portletRequestModel, themeDisplay);
602    
603                            Object returnObj = null;
604    
605                            try {
606                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
607                            }
608                            catch (Exception e) {
609                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
610                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
611                                    }
612    
613                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
614                            }
615    
616                            return (java.lang.String)returnObj;
617                    }
618                    catch (com.liferay.portal.kernel.exception.SystemException se) {
619                            _log.error(se, se);
620    
621                            throw se;
622                    }
623            }
624    
625            public static java.lang.String getArticleContent(
626                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
627                    java.lang.String languageId,
628                    com.liferay.portal.theme.ThemeDisplay themeDisplay)
629                    throws com.liferay.portal.kernel.exception.PortalException {
630                    try {
631                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
632                                            "getArticleContent", _getArticleContentParameterTypes16);
633    
634                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
635                                            articleId, languageId, themeDisplay);
636    
637                            Object returnObj = null;
638    
639                            try {
640                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
641                            }
642                            catch (Exception e) {
643                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
644                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
645                                    }
646    
647                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
648                            }
649    
650                            return (java.lang.String)returnObj;
651                    }
652                    catch (com.liferay.portal.kernel.exception.SystemException se) {
653                            _log.error(se, se);
654    
655                            throw se;
656                    }
657            }
658    
659            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticles(
660                    HttpPrincipal httpPrincipal, long groupId, long folderId) {
661                    try {
662                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
663                                            "getArticles", _getArticlesParameterTypes17);
664    
665                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
666                                            folderId);
667    
668                            Object returnObj = null;
669    
670                            try {
671                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
672                            }
673                            catch (Exception e) {
674                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
675                            }
676    
677                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
678                    }
679                    catch (com.liferay.portal.kernel.exception.SystemException se) {
680                            _log.error(se, se);
681    
682                            throw se;
683                    }
684            }
685    
686            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticles(
687                    HttpPrincipal httpPrincipal, long groupId, long folderId, int start,
688                    int end,
689                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
690                    try {
691                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
692                                            "getArticles", _getArticlesParameterTypes18);
693    
694                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
695                                            folderId, start, end, obc);
696    
697                            Object returnObj = null;
698    
699                            try {
700                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
701                            }
702                            catch (Exception e) {
703                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
704                            }
705    
706                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
707                    }
708                    catch (com.liferay.portal.kernel.exception.SystemException se) {
709                            _log.error(se, se);
710    
711                            throw se;
712                    }
713            }
714    
715            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByArticleId(
716                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
717                    int start, int end,
718                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
719                    try {
720                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
721                                            "getArticlesByArticleId",
722                                            _getArticlesByArticleIdParameterTypes19);
723    
724                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
725                                            articleId, start, end, obc);
726    
727                            Object returnObj = null;
728    
729                            try {
730                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
731                            }
732                            catch (Exception e) {
733                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
734                            }
735    
736                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
737                    }
738                    catch (com.liferay.portal.kernel.exception.SystemException se) {
739                            _log.error(se, se);
740    
741                            throw se;
742                    }
743            }
744    
745            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByLayoutUuid(
746                    HttpPrincipal httpPrincipal, long groupId, java.lang.String layoutUuid) {
747                    try {
748                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
749                                            "getArticlesByLayoutUuid",
750                                            _getArticlesByLayoutUuidParameterTypes20);
751    
752                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
753                                            layoutUuid);
754    
755                            Object returnObj = null;
756    
757                            try {
758                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
759                            }
760                            catch (Exception e) {
761                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
762                            }
763    
764                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
765                    }
766                    catch (com.liferay.portal.kernel.exception.SystemException se) {
767                            _log.error(se, se);
768    
769                            throw se;
770                    }
771            }
772    
773            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByStructureId(
774                    HttpPrincipal httpPrincipal, long groupId, long classNameId,
775                    java.lang.String ddmStructureKey, int status, int start, int end,
776                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
777                    try {
778                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
779                                            "getArticlesByStructureId",
780                                            _getArticlesByStructureIdParameterTypes21);
781    
782                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
783                                            classNameId, ddmStructureKey, status, start, end, obc);
784    
785                            Object returnObj = null;
786    
787                            try {
788                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
789                            }
790                            catch (Exception e) {
791                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
792                            }
793    
794                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
795                    }
796                    catch (com.liferay.portal.kernel.exception.SystemException se) {
797                            _log.error(se, se);
798    
799                            throw se;
800                    }
801            }
802    
803            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getArticlesByStructureId(
804                    HttpPrincipal httpPrincipal, long groupId,
805                    java.lang.String ddmStructureKey, int start, int end,
806                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
807                    try {
808                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
809                                            "getArticlesByStructureId",
810                                            _getArticlesByStructureIdParameterTypes22);
811    
812                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
813                                            ddmStructureKey, start, end, obc);
814    
815                            Object returnObj = null;
816    
817                            try {
818                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
819                            }
820                            catch (Exception e) {
821                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
822                            }
823    
824                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
825                    }
826                    catch (com.liferay.portal.kernel.exception.SystemException se) {
827                            _log.error(se, se);
828    
829                            throw se;
830                    }
831            }
832    
833            public static int getArticlesCount(HttpPrincipal httpPrincipal,
834                    long groupId, long folderId) {
835                    try {
836                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
837                                            "getArticlesCount", _getArticlesCountParameterTypes23);
838    
839                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
840                                            folderId);
841    
842                            Object returnObj = null;
843    
844                            try {
845                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
846                            }
847                            catch (Exception e) {
848                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
849                            }
850    
851                            return ((Integer)returnObj).intValue();
852                    }
853                    catch (com.liferay.portal.kernel.exception.SystemException se) {
854                            _log.error(se, se);
855    
856                            throw se;
857                    }
858            }
859    
860            public static int getArticlesCount(HttpPrincipal httpPrincipal,
861                    long groupId, long folderId, int status) {
862                    try {
863                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
864                                            "getArticlesCount", _getArticlesCountParameterTypes24);
865    
866                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
867                                            folderId, status);
868    
869                            Object returnObj = null;
870    
871                            try {
872                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
873                            }
874                            catch (Exception e) {
875                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
876                            }
877    
878                            return ((Integer)returnObj).intValue();
879                    }
880                    catch (com.liferay.portal.kernel.exception.SystemException se) {
881                            _log.error(se, se);
882    
883                            throw se;
884                    }
885            }
886    
887            public static int getArticlesCountByArticleId(HttpPrincipal httpPrincipal,
888                    long groupId, java.lang.String articleId) {
889                    try {
890                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
891                                            "getArticlesCountByArticleId",
892                                            _getArticlesCountByArticleIdParameterTypes25);
893    
894                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
895                                            articleId);
896    
897                            Object returnObj = null;
898    
899                            try {
900                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
901                            }
902                            catch (Exception e) {
903                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
904                            }
905    
906                            return ((Integer)returnObj).intValue();
907                    }
908                    catch (com.liferay.portal.kernel.exception.SystemException se) {
909                            _log.error(se, se);
910    
911                            throw se;
912                    }
913            }
914    
915            public static int getArticlesCountByStructureId(
916                    HttpPrincipal httpPrincipal, long groupId, long classNameId,
917                    java.lang.String ddmStructureKey, int status) {
918                    try {
919                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
920                                            "getArticlesCountByStructureId",
921                                            _getArticlesCountByStructureIdParameterTypes26);
922    
923                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
924                                            classNameId, ddmStructureKey, status);
925    
926                            Object returnObj = null;
927    
928                            try {
929                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
930                            }
931                            catch (Exception e) {
932                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
933                            }
934    
935                            return ((Integer)returnObj).intValue();
936                    }
937                    catch (com.liferay.portal.kernel.exception.SystemException se) {
938                            _log.error(se, se);
939    
940                            throw se;
941                    }
942            }
943    
944            public static int getArticlesCountByStructureId(
945                    HttpPrincipal httpPrincipal, long groupId,
946                    java.lang.String ddmStructureKey) {
947                    try {
948                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
949                                            "getArticlesCountByStructureId",
950                                            _getArticlesCountByStructureIdParameterTypes27);
951    
952                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
953                                            ddmStructureKey);
954    
955                            Object returnObj = null;
956    
957                            try {
958                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
959                            }
960                            catch (Exception e) {
961                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
962                            }
963    
964                            return ((Integer)returnObj).intValue();
965                    }
966                    catch (com.liferay.portal.kernel.exception.SystemException se) {
967                            _log.error(se, se);
968    
969                            throw se;
970                    }
971            }
972    
973            public static com.liferay.portlet.journal.model.JournalArticle getDisplayArticleByUrlTitle(
974                    HttpPrincipal httpPrincipal, long groupId, java.lang.String urlTitle)
975                    throws com.liferay.portal.kernel.exception.PortalException {
976                    try {
977                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
978                                            "getDisplayArticleByUrlTitle",
979                                            _getDisplayArticleByUrlTitleParameterTypes28);
980    
981                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
982                                            urlTitle);
983    
984                            Object returnObj = null;
985    
986                            try {
987                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
988                            }
989                            catch (Exception e) {
990                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
991                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
992                                    }
993    
994                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
995                            }
996    
997                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
998                    }
999                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1000                            _log.error(se, se);
1001    
1002                            throw se;
1003                    }
1004            }
1005    
1006            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
1007                    long groupId, java.util.List<java.lang.Long> folderIds) {
1008                    try {
1009                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1010                                            "getFoldersAndArticlesCount",
1011                                            _getFoldersAndArticlesCountParameterTypes29);
1012    
1013                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1014                                            folderIds);
1015    
1016                            Object returnObj = null;
1017    
1018                            try {
1019                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1020                            }
1021                            catch (Exception e) {
1022                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1023                            }
1024    
1025                            return ((Integer)returnObj).intValue();
1026                    }
1027                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1028                            _log.error(se, se);
1029    
1030                            throw se;
1031                    }
1032            }
1033    
1034            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getGroupArticles(
1035                    HttpPrincipal httpPrincipal, long groupId, long userId,
1036                    long rootFolderId, int status, int start, int end,
1037                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1038                    throws com.liferay.portal.kernel.exception.PortalException {
1039                    try {
1040                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1041                                            "getGroupArticles", _getGroupArticlesParameterTypes30);
1042    
1043                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1044                                            userId, rootFolderId, status, start, end, orderByComparator);
1045    
1046                            Object returnObj = null;
1047    
1048                            try {
1049                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1050                            }
1051                            catch (Exception e) {
1052                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1053                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1054                                    }
1055    
1056                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1057                            }
1058    
1059                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1060                    }
1061                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1062                            _log.error(se, se);
1063    
1064                            throw se;
1065                    }
1066            }
1067    
1068            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> getGroupArticles(
1069                    HttpPrincipal httpPrincipal, long groupId, long userId,
1070                    long rootFolderId, int start, int end,
1071                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1072                    throws com.liferay.portal.kernel.exception.PortalException {
1073                    try {
1074                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1075                                            "getGroupArticles", _getGroupArticlesParameterTypes31);
1076    
1077                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1078                                            userId, rootFolderId, start, end, orderByComparator);
1079    
1080                            Object returnObj = null;
1081    
1082                            try {
1083                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1084                            }
1085                            catch (Exception e) {
1086                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1087                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1088                                    }
1089    
1090                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1091                            }
1092    
1093                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1094                    }
1095                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1096                            _log.error(se, se);
1097    
1098                            throw se;
1099                    }
1100            }
1101    
1102            public static int getGroupArticlesCount(HttpPrincipal httpPrincipal,
1103                    long groupId, long userId, long rootFolderId)
1104                    throws com.liferay.portal.kernel.exception.PortalException {
1105                    try {
1106                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1107                                            "getGroupArticlesCount",
1108                                            _getGroupArticlesCountParameterTypes32);
1109    
1110                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1111                                            userId, rootFolderId);
1112    
1113                            Object returnObj = null;
1114    
1115                            try {
1116                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1117                            }
1118                            catch (Exception e) {
1119                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1120                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1121                                    }
1122    
1123                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1124                            }
1125    
1126                            return ((Integer)returnObj).intValue();
1127                    }
1128                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1129                            _log.error(se, se);
1130    
1131                            throw se;
1132                    }
1133            }
1134    
1135            public static int getGroupArticlesCount(HttpPrincipal httpPrincipal,
1136                    long groupId, long userId, long rootFolderId, int status)
1137                    throws com.liferay.portal.kernel.exception.PortalException {
1138                    try {
1139                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1140                                            "getGroupArticlesCount",
1141                                            _getGroupArticlesCountParameterTypes33);
1142    
1143                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1144                                            userId, rootFolderId, status);
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 ((Integer)returnObj).intValue();
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 resourcePrimKey)
1170                    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,
1176                                            resourcePrimKey);
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 articleId,
1202                    int status) throws com.liferay.portal.kernel.exception.PortalException {
1203                    try {
1204                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1205                                            "getLatestArticle", _getLatestArticleParameterTypes35);
1206    
1207                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1208                                            articleId, status);
1209    
1210                            Object returnObj = null;
1211    
1212                            try {
1213                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1214                            }
1215                            catch (Exception e) {
1216                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1217                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1218                                    }
1219    
1220                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1221                            }
1222    
1223                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1224                    }
1225                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1226                            _log.error(se, se);
1227    
1228                            throw se;
1229                    }
1230            }
1231    
1232            public static com.liferay.portlet.journal.model.JournalArticle getLatestArticle(
1233                    HttpPrincipal httpPrincipal, long groupId, java.lang.String className,
1234                    long classPK)
1235                    throws com.liferay.portal.kernel.exception.PortalException {
1236                    try {
1237                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1238                                            "getLatestArticle", _getLatestArticleParameterTypes36);
1239    
1240                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1241                                            className, classPK);
1242    
1243                            Object returnObj = null;
1244    
1245                            try {
1246                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1247                            }
1248                            catch (Exception e) {
1249                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1250                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1251                                    }
1252    
1253                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1254                            }
1255    
1256                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1257                    }
1258                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1259                            _log.error(se, se);
1260    
1261                            throw se;
1262                    }
1263            }
1264    
1265            public static void moveArticle(HttpPrincipal httpPrincipal, long groupId,
1266                    java.lang.String articleId, long newFolderId)
1267                    throws com.liferay.portal.kernel.exception.PortalException {
1268                    try {
1269                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1270                                            "moveArticle", _moveArticleParameterTypes37);
1271    
1272                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1273                                            articleId, newFolderId);
1274    
1275                            try {
1276                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1277                            }
1278                            catch (Exception e) {
1279                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1280                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1281                                    }
1282    
1283                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1284                            }
1285                    }
1286                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1287                            _log.error(se, se);
1288    
1289                            throw se;
1290                    }
1291            }
1292    
1293            public static void moveArticle(HttpPrincipal httpPrincipal, long groupId,
1294                    java.lang.String articleId, long newFolderId,
1295                    com.liferay.portal.service.ServiceContext serviceContext)
1296                    throws com.liferay.portal.kernel.exception.PortalException {
1297                    try {
1298                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1299                                            "moveArticle", _moveArticleParameterTypes38);
1300    
1301                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1302                                            articleId, newFolderId, serviceContext);
1303    
1304                            try {
1305                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1306                            }
1307                            catch (Exception e) {
1308                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1309                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1310                                    }
1311    
1312                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1313                            }
1314                    }
1315                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1316                            _log.error(se, se);
1317    
1318                            throw se;
1319                    }
1320            }
1321    
1322            public static com.liferay.portlet.journal.model.JournalArticle moveArticleFromTrash(
1323                    HttpPrincipal httpPrincipal, long groupId, long resourcePrimKey,
1324                    long newFolderId,
1325                    com.liferay.portal.service.ServiceContext serviceContext)
1326                    throws com.liferay.portal.kernel.exception.PortalException {
1327                    try {
1328                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1329                                            "moveArticleFromTrash",
1330                                            _moveArticleFromTrashParameterTypes39);
1331    
1332                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1333                                            resourcePrimKey, newFolderId, serviceContext);
1334    
1335                            Object returnObj = null;
1336    
1337                            try {
1338                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1339                            }
1340                            catch (Exception e) {
1341                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1342                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1343                                    }
1344    
1345                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1346                            }
1347    
1348                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1349                    }
1350                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1351                            _log.error(se, se);
1352    
1353                            throw se;
1354                    }
1355            }
1356    
1357            public static com.liferay.portlet.journal.model.JournalArticle moveArticleFromTrash(
1358                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1359                    long newFolderId,
1360                    com.liferay.portal.service.ServiceContext serviceContext)
1361                    throws com.liferay.portal.kernel.exception.PortalException {
1362                    try {
1363                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1364                                            "moveArticleFromTrash",
1365                                            _moveArticleFromTrashParameterTypes40);
1366    
1367                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1368                                            articleId, newFolderId, serviceContext);
1369    
1370                            Object returnObj = null;
1371    
1372                            try {
1373                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1374                            }
1375                            catch (Exception e) {
1376                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1377                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1378                                    }
1379    
1380                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1381                            }
1382    
1383                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1384                    }
1385                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1386                            _log.error(se, se);
1387    
1388                            throw se;
1389                    }
1390            }
1391    
1392            public static com.liferay.portlet.journal.model.JournalArticle moveArticleToTrash(
1393                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId)
1394                    throws com.liferay.portal.kernel.exception.PortalException {
1395                    try {
1396                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1397                                            "moveArticleToTrash", _moveArticleToTrashParameterTypes41);
1398    
1399                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1400                                            articleId);
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 removeArticleLocale(HttpPrincipal httpPrincipal,
1425                    long companyId, java.lang.String languageId)
1426                    throws com.liferay.portal.kernel.exception.PortalException {
1427                    try {
1428                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1429                                            "removeArticleLocale", _removeArticleLocaleParameterTypes42);
1430    
1431                            MethodHandler methodHandler = new MethodHandler(methodKey,
1432                                            companyId, languageId);
1433    
1434                            try {
1435                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1436                            }
1437                            catch (Exception e) {
1438                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1439                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1440                                    }
1441    
1442                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1443                            }
1444                    }
1445                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1446                            _log.error(se, se);
1447    
1448                            throw se;
1449                    }
1450            }
1451    
1452            public static com.liferay.portlet.journal.model.JournalArticle removeArticleLocale(
1453                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1454                    double version, java.lang.String languageId)
1455                    throws com.liferay.portal.kernel.exception.PortalException {
1456                    try {
1457                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1458                                            "removeArticleLocale", _removeArticleLocaleParameterTypes43);
1459    
1460                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1461                                            articleId, version, languageId);
1462    
1463                            Object returnObj = null;
1464    
1465                            try {
1466                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1467                            }
1468                            catch (Exception e) {
1469                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1470                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1471                                    }
1472    
1473                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1474                            }
1475    
1476                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1477                    }
1478                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1479                            _log.error(se, se);
1480    
1481                            throw se;
1482                    }
1483            }
1484    
1485            public static void restoreArticleFromTrash(HttpPrincipal httpPrincipal,
1486                    long resourcePrimKey)
1487                    throws com.liferay.portal.kernel.exception.PortalException {
1488                    try {
1489                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1490                                            "restoreArticleFromTrash",
1491                                            _restoreArticleFromTrashParameterTypes44);
1492    
1493                            MethodHandler methodHandler = new MethodHandler(methodKey,
1494                                            resourcePrimKey);
1495    
1496                            try {
1497                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1498                            }
1499                            catch (Exception e) {
1500                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1501                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1502                                    }
1503    
1504                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1505                            }
1506                    }
1507                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1508                            _log.error(se, se);
1509    
1510                            throw se;
1511                    }
1512            }
1513    
1514            public static void restoreArticleFromTrash(HttpPrincipal httpPrincipal,
1515                    long groupId, java.lang.String articleId)
1516                    throws com.liferay.portal.kernel.exception.PortalException {
1517                    try {
1518                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1519                                            "restoreArticleFromTrash",
1520                                            _restoreArticleFromTrashParameterTypes45);
1521    
1522                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1523                                            articleId);
1524    
1525                            try {
1526                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1527                            }
1528                            catch (Exception e) {
1529                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1530                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1531                                    }
1532    
1533                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1534                            }
1535                    }
1536                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1537                            _log.error(se, se);
1538    
1539                            throw se;
1540                    }
1541            }
1542    
1543            public static com.liferay.portal.kernel.search.Hits search(
1544                    HttpPrincipal httpPrincipal, long groupId, long creatorUserId,
1545                    int status, int start, int end)
1546                    throws com.liferay.portal.kernel.exception.PortalException {
1547                    try {
1548                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1549                                            "search", _searchParameterTypes46);
1550    
1551                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1552                                            creatorUserId, status, start, end);
1553    
1554                            Object returnObj = null;
1555    
1556                            try {
1557                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1558                            }
1559                            catch (Exception e) {
1560                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1561                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1562                                    }
1563    
1564                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1565                            }
1566    
1567                            return (com.liferay.portal.kernel.search.Hits)returnObj;
1568                    }
1569                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1570                            _log.error(se, se);
1571    
1572                            throw se;
1573                    }
1574            }
1575    
1576            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1577                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1578                    java.util.List<java.lang.Long> folderIds, long classNameId,
1579                    java.lang.String keywords, java.lang.Double version,
1580                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
1581                    java.util.Date displayDateGT, java.util.Date displayDateLT, int status,
1582                    java.util.Date reviewDate, int start, int end,
1583                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1584                    try {
1585                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1586                                            "search", _searchParameterTypes47);
1587    
1588                            MethodHandler methodHandler = new MethodHandler(methodKey,
1589                                            companyId, groupId, folderIds, classNameId, keywords,
1590                                            version, ddmStructureKey, ddmTemplateKey, displayDateGT,
1591                                            displayDateLT, status, reviewDate, start, end, obc);
1592    
1593                            Object returnObj = null;
1594    
1595                            try {
1596                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1597                            }
1598                            catch (Exception e) {
1599                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1600                            }
1601    
1602                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1603                    }
1604                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1605                            _log.error(se, se);
1606    
1607                            throw se;
1608                    }
1609            }
1610    
1611            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1612                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1613                    java.util.List<java.lang.Long> folderIds, long classNameId,
1614                    java.lang.String articleId, java.lang.Double version,
1615                    java.lang.String title, java.lang.String description,
1616                    java.lang.String content, java.lang.String ddmStructureKey,
1617                    java.lang.String ddmTemplateKey, java.util.Date displayDateGT,
1618                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1619                    boolean andOperator, int start, int end,
1620                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1621                    try {
1622                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1623                                            "search", _searchParameterTypes48);
1624    
1625                            MethodHandler methodHandler = new MethodHandler(methodKey,
1626                                            companyId, groupId, folderIds, classNameId, articleId,
1627                                            version, title, description, content, ddmStructureKey,
1628                                            ddmTemplateKey, displayDateGT, displayDateLT, status,
1629                                            reviewDate, andOperator, start, end, obc);
1630    
1631                            Object returnObj = null;
1632    
1633                            try {
1634                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1635                            }
1636                            catch (Exception e) {
1637                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1638                            }
1639    
1640                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1641                    }
1642                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1643                            _log.error(se, se);
1644    
1645                            throw se;
1646                    }
1647            }
1648    
1649            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> search(
1650                    HttpPrincipal httpPrincipal, long companyId, long groupId,
1651                    java.util.List<java.lang.Long> folderIds, long classNameId,
1652                    java.lang.String articleId, java.lang.Double version,
1653                    java.lang.String title, java.lang.String description,
1654                    java.lang.String content, java.lang.String[] ddmStructureKeys,
1655                    java.lang.String[] ddmTemplateKeys, java.util.Date displayDateGT,
1656                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1657                    boolean andOperator, int start, int end,
1658                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> obc) {
1659                    try {
1660                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1661                                            "search", _searchParameterTypes49);
1662    
1663                            MethodHandler methodHandler = new MethodHandler(methodKey,
1664                                            companyId, groupId, folderIds, classNameId, articleId,
1665                                            version, title, description, content, ddmStructureKeys,
1666                                            ddmTemplateKeys, displayDateGT, displayDateLT, status,
1667                                            reviewDate, andOperator, start, end, obc);
1668    
1669                            Object returnObj = null;
1670    
1671                            try {
1672                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1673                            }
1674                            catch (Exception e) {
1675                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1676                            }
1677    
1678                            return (java.util.List<com.liferay.portlet.journal.model.JournalArticle>)returnObj;
1679                    }
1680                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1681                            _log.error(se, se);
1682    
1683                            throw se;
1684                    }
1685            }
1686    
1687            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1688                    long groupId, java.util.List<java.lang.Long> folderIds,
1689                    long classNameId, java.lang.String keywords, java.lang.Double version,
1690                    java.lang.String ddmStructureKey, java.lang.String ddmTemplateKey,
1691                    java.util.Date displayDateGT, java.util.Date displayDateLT, int status,
1692                    java.util.Date reviewDate) {
1693                    try {
1694                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1695                                            "searchCount", _searchCountParameterTypes50);
1696    
1697                            MethodHandler methodHandler = new MethodHandler(methodKey,
1698                                            companyId, groupId, folderIds, classNameId, keywords,
1699                                            version, ddmStructureKey, ddmTemplateKey, displayDateGT,
1700                                            displayDateLT, status, reviewDate);
1701    
1702                            Object returnObj = null;
1703    
1704                            try {
1705                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1706                            }
1707                            catch (Exception e) {
1708                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1709                            }
1710    
1711                            return ((Integer)returnObj).intValue();
1712                    }
1713                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1714                            _log.error(se, se);
1715    
1716                            throw se;
1717                    }
1718            }
1719    
1720            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1721                    long groupId, java.util.List<java.lang.Long> folderIds,
1722                    long classNameId, java.lang.String articleId, java.lang.Double version,
1723                    java.lang.String title, java.lang.String description,
1724                    java.lang.String content, java.lang.String ddmStructureKey,
1725                    java.lang.String ddmTemplateKey, java.util.Date displayDateGT,
1726                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1727                    boolean andOperator) {
1728                    try {
1729                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1730                                            "searchCount", _searchCountParameterTypes51);
1731    
1732                            MethodHandler methodHandler = new MethodHandler(methodKey,
1733                                            companyId, groupId, folderIds, classNameId, articleId,
1734                                            version, title, description, content, ddmStructureKey,
1735                                            ddmTemplateKey, displayDateGT, displayDateLT, status,
1736                                            reviewDate, andOperator);
1737    
1738                            Object returnObj = null;
1739    
1740                            try {
1741                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1742                            }
1743                            catch (Exception e) {
1744                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1745                            }
1746    
1747                            return ((Integer)returnObj).intValue();
1748                    }
1749                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1750                            _log.error(se, se);
1751    
1752                            throw se;
1753                    }
1754            }
1755    
1756            public static int searchCount(HttpPrincipal httpPrincipal, long companyId,
1757                    long groupId, java.util.List<java.lang.Long> folderIds,
1758                    long classNameId, java.lang.String articleId, java.lang.Double version,
1759                    java.lang.String title, java.lang.String description,
1760                    java.lang.String content, java.lang.String[] ddmStructureKeys,
1761                    java.lang.String[] ddmTemplateKeys, java.util.Date displayDateGT,
1762                    java.util.Date displayDateLT, int status, java.util.Date reviewDate,
1763                    boolean andOperator) {
1764                    try {
1765                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1766                                            "searchCount", _searchCountParameterTypes52);
1767    
1768                            MethodHandler methodHandler = new MethodHandler(methodKey,
1769                                            companyId, groupId, folderIds, classNameId, articleId,
1770                                            version, title, description, content, ddmStructureKeys,
1771                                            ddmTemplateKeys, displayDateGT, displayDateLT, status,
1772                                            reviewDate, andOperator);
1773    
1774                            Object returnObj = null;
1775    
1776                            try {
1777                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1778                            }
1779                            catch (Exception e) {
1780                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1781                            }
1782    
1783                            return ((Integer)returnObj).intValue();
1784                    }
1785                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1786                            _log.error(se, se);
1787    
1788                            throw se;
1789                    }
1790            }
1791    
1792            public static void subscribeStructure(HttpPrincipal httpPrincipal,
1793                    long groupId, long userId, long ddmStructureId)
1794                    throws com.liferay.portal.kernel.exception.PortalException {
1795                    try {
1796                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1797                                            "subscribeStructure", _subscribeStructureParameterTypes53);
1798    
1799                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1800                                            userId, ddmStructureId);
1801    
1802                            try {
1803                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1804                            }
1805                            catch (Exception e) {
1806                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1807                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1808                                    }
1809    
1810                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1811                            }
1812                    }
1813                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1814                            _log.error(se, se);
1815    
1816                            throw se;
1817                    }
1818            }
1819    
1820            public static void unsubscribeStructure(HttpPrincipal httpPrincipal,
1821                    long groupId, long userId, long ddmStructureId)
1822                    throws com.liferay.portal.kernel.exception.PortalException {
1823                    try {
1824                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1825                                            "unsubscribeStructure",
1826                                            _unsubscribeStructureParameterTypes54);
1827    
1828                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1829                                            userId, ddmStructureId);
1830    
1831                            try {
1832                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1833                            }
1834                            catch (Exception e) {
1835                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1836                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1837                                    }
1838    
1839                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1840                            }
1841                    }
1842                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1843                            _log.error(se, se);
1844    
1845                            throw se;
1846                    }
1847            }
1848    
1849            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1850                    HttpPrincipal httpPrincipal, long userId, long groupId, long folderId,
1851                    java.lang.String articleId, double version,
1852                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1853                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1854                    java.lang.String content, java.lang.String layoutUuid,
1855                    com.liferay.portal.service.ServiceContext serviceContext)
1856                    throws com.liferay.portal.kernel.exception.PortalException {
1857                    try {
1858                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1859                                            "updateArticle", _updateArticleParameterTypes55);
1860    
1861                            MethodHandler methodHandler = new MethodHandler(methodKey, userId,
1862                                            groupId, folderId, articleId, version, titleMap,
1863                                            descriptionMap, content, layoutUuid, serviceContext);
1864    
1865                            Object returnObj = null;
1866    
1867                            try {
1868                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1869                            }
1870                            catch (Exception e) {
1871                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1872                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1873                                    }
1874    
1875                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1876                            }
1877    
1878                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1879                    }
1880                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1881                            _log.error(se, se);
1882    
1883                            throw se;
1884                    }
1885            }
1886    
1887            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1888                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1889                    java.lang.String articleId, double version,
1890                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1891                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1892                    java.lang.String content, java.lang.String ddmStructureKey,
1893                    java.lang.String ddmTemplateKey, java.lang.String layoutUuid,
1894                    int displayDateMonth, int displayDateDay, int displayDateYear,
1895                    int displayDateHour, int displayDateMinute, int expirationDateMonth,
1896                    int expirationDateDay, int expirationDateYear, int expirationDateHour,
1897                    int expirationDateMinute, boolean neverExpire, int reviewDateMonth,
1898                    int reviewDateDay, int reviewDateYear, int reviewDateHour,
1899                    int reviewDateMinute, boolean neverReview, boolean indexable,
1900                    boolean smallImage, java.lang.String smallImageURL,
1901                    java.io.File smallFile, java.util.Map<java.lang.String, byte[]> images,
1902                    java.lang.String articleURL,
1903                    com.liferay.portal.service.ServiceContext serviceContext)
1904                    throws com.liferay.portal.kernel.exception.PortalException {
1905                    try {
1906                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1907                                            "updateArticle", _updateArticleParameterTypes56);
1908    
1909                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1910                                            folderId, articleId, version, titleMap, descriptionMap,
1911                                            content, ddmStructureKey, ddmTemplateKey, layoutUuid,
1912                                            displayDateMonth, displayDateDay, displayDateYear,
1913                                            displayDateHour, displayDateMinute, expirationDateMonth,
1914                                            expirationDateDay, expirationDateYear, expirationDateHour,
1915                                            expirationDateMinute, neverExpire, reviewDateMonth,
1916                                            reviewDateDay, reviewDateYear, reviewDateHour,
1917                                            reviewDateMinute, neverReview, indexable, smallImage,
1918                                            smallImageURL, smallFile, images, articleURL, serviceContext);
1919    
1920                            Object returnObj = null;
1921    
1922                            try {
1923                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1924                            }
1925                            catch (Exception e) {
1926                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1927                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1928                                    }
1929    
1930                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1931                            }
1932    
1933                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1934                    }
1935                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1936                            _log.error(se, se);
1937    
1938                            throw se;
1939                    }
1940            }
1941    
1942            public static com.liferay.portlet.journal.model.JournalArticle updateArticle(
1943                    HttpPrincipal httpPrincipal, long groupId, long folderId,
1944                    java.lang.String articleId, double version, java.lang.String content,
1945                    com.liferay.portal.service.ServiceContext serviceContext)
1946                    throws com.liferay.portal.kernel.exception.PortalException {
1947                    try {
1948                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1949                                            "updateArticle", _updateArticleParameterTypes57);
1950    
1951                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1952                                            folderId, articleId, version, content, serviceContext);
1953    
1954                            Object returnObj = null;
1955    
1956                            try {
1957                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1958                            }
1959                            catch (Exception e) {
1960                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1961                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1962                                    }
1963    
1964                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1965                            }
1966    
1967                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
1968                    }
1969                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1970                            _log.error(se, se);
1971    
1972                            throw se;
1973                    }
1974            }
1975    
1976            public static com.liferay.portlet.journal.model.JournalArticle updateArticleTranslation(
1977                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
1978                    double version, java.util.Locale locale, java.lang.String title,
1979                    java.lang.String description, java.lang.String content,
1980                    java.util.Map<java.lang.String, byte[]> images)
1981                    throws com.liferay.portal.kernel.exception.PortalException {
1982                    try {
1983                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
1984                                            "updateArticleTranslation",
1985                                            _updateArticleTranslationParameterTypes58);
1986    
1987                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1988                                            articleId, version, locale, title, description, content,
1989                                            images);
1990    
1991                            Object returnObj = null;
1992    
1993                            try {
1994                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1995                            }
1996                            catch (Exception e) {
1997                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1998                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1999                                    }
2000    
2001                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2002                            }
2003    
2004                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2005                    }
2006                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2007                            _log.error(se, se);
2008    
2009                            throw se;
2010                    }
2011            }
2012    
2013            public static com.liferay.portlet.journal.model.JournalArticle updateArticleTranslation(
2014                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
2015                    double version, java.util.Locale locale, java.lang.String title,
2016                    java.lang.String description, java.lang.String content,
2017                    java.util.Map<java.lang.String, byte[]> images,
2018                    com.liferay.portal.service.ServiceContext serviceContext)
2019                    throws com.liferay.portal.kernel.exception.PortalException {
2020                    try {
2021                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
2022                                            "updateArticleTranslation",
2023                                            _updateArticleTranslationParameterTypes59);
2024    
2025                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2026                                            articleId, version, locale, title, description, content,
2027                                            images, serviceContext);
2028    
2029                            Object returnObj = null;
2030    
2031                            try {
2032                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2033                            }
2034                            catch (Exception e) {
2035                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2036                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2037                                    }
2038    
2039                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2040                            }
2041    
2042                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2043                    }
2044                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2045                            _log.error(se, se);
2046    
2047                            throw se;
2048                    }
2049            }
2050    
2051            public static com.liferay.portlet.journal.model.JournalArticle updateContent(
2052                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
2053                    double version, java.lang.String content)
2054                    throws com.liferay.portal.kernel.exception.PortalException {
2055                    try {
2056                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
2057                                            "updateContent", _updateContentParameterTypes60);
2058    
2059                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2060                                            articleId, version, content);
2061    
2062                            Object returnObj = null;
2063    
2064                            try {
2065                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2066                            }
2067                            catch (Exception e) {
2068                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2069                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2070                                    }
2071    
2072                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2073                            }
2074    
2075                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2076                    }
2077                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2078                            _log.error(se, se);
2079    
2080                            throw se;
2081                    }
2082            }
2083    
2084            public static com.liferay.portlet.journal.model.JournalArticle updateStatus(
2085                    HttpPrincipal httpPrincipal, long groupId, java.lang.String articleId,
2086                    double version, int status, java.lang.String articleURL,
2087                    com.liferay.portal.service.ServiceContext serviceContext)
2088                    throws com.liferay.portal.kernel.exception.PortalException {
2089                    try {
2090                            MethodKey methodKey = new MethodKey(JournalArticleServiceUtil.class,
2091                                            "updateStatus", _updateStatusParameterTypes61);
2092    
2093                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2094                                            articleId, version, status, articleURL, serviceContext);
2095    
2096                            Object returnObj = null;
2097    
2098                            try {
2099                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2100                            }
2101                            catch (Exception e) {
2102                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2103                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2104                                    }
2105    
2106                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2107                            }
2108    
2109                            return (com.liferay.portlet.journal.model.JournalArticle)returnObj;
2110                    }
2111                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2112                            _log.error(se, se);
2113    
2114                            throw se;
2115                    }
2116            }
2117    
2118            private static Log _log = LogFactoryUtil.getLog(JournalArticleServiceHttp.class);
2119            private static final Class<?>[] _addArticleParameterTypes0 = new Class[] {
2120                            long.class, long.class, long.class, long.class,
2121                            java.lang.String.class, boolean.class, java.util.Map.class,
2122                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2123                            java.lang.String.class, java.lang.String.class, int.class, int.class,
2124                            int.class, int.class, int.class, int.class, int.class, int.class,
2125                            int.class, int.class, boolean.class, int.class, int.class, int.class,
2126                            int.class, int.class, boolean.class, boolean.class, boolean.class,
2127                            java.lang.String.class, java.io.File.class, java.util.Map.class,
2128                            java.lang.String.class,
2129                            com.liferay.portal.service.ServiceContext.class
2130                    };
2131            private static final Class<?>[] _addArticleParameterTypes1 = new Class[] {
2132                            long.class, long.class, long.class, long.class,
2133                            java.lang.String.class, boolean.class, java.util.Map.class,
2134                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2135                            java.lang.String.class, java.lang.String.class, int.class, int.class,
2136                            int.class, int.class, int.class, int.class, int.class, int.class,
2137                            int.class, int.class, boolean.class, int.class, int.class, int.class,
2138                            int.class, int.class, boolean.class, boolean.class,
2139                            java.lang.String.class,
2140                            com.liferay.portal.service.ServiceContext.class
2141                    };
2142            private static final Class<?>[] _copyArticleParameterTypes2 = new Class[] {
2143                            long.class, java.lang.String.class, java.lang.String.class,
2144                            boolean.class, double.class
2145                    };
2146            private static final Class<?>[] _deleteArticleParameterTypes3 = new Class[] {
2147                            long.class, java.lang.String.class, double.class,
2148                            java.lang.String.class,
2149                            com.liferay.portal.service.ServiceContext.class
2150                    };
2151            private static final Class<?>[] _deleteArticleParameterTypes4 = new Class[] {
2152                            long.class, java.lang.String.class, java.lang.String.class,
2153                            com.liferay.portal.service.ServiceContext.class
2154                    };
2155            private static final Class<?>[] _expireArticleParameterTypes5 = new Class[] {
2156                            long.class, java.lang.String.class, double.class,
2157                            java.lang.String.class,
2158                            com.liferay.portal.service.ServiceContext.class
2159                    };
2160            private static final Class<?>[] _expireArticleParameterTypes6 = new Class[] {
2161                            long.class, java.lang.String.class, java.lang.String.class,
2162                            com.liferay.portal.service.ServiceContext.class
2163                    };
2164            private static final Class<?>[] _fetchArticleParameterTypes7 = new Class[] {
2165                            long.class, java.lang.String.class
2166                    };
2167            private static final Class<?>[] _getArticleParameterTypes8 = new Class[] {
2168                            long.class
2169                    };
2170            private static final Class<?>[] _getArticleParameterTypes9 = new Class[] {
2171                            long.class, java.lang.String.class
2172                    };
2173            private static final Class<?>[] _getArticleParameterTypes10 = new Class[] {
2174                            long.class, java.lang.String.class, double.class
2175                    };
2176            private static final Class<?>[] _getArticleParameterTypes11 = new Class[] {
2177                            long.class, java.lang.String.class, long.class
2178                    };
2179            private static final Class<?>[] _getArticleByUrlTitleParameterTypes12 = new Class[] {
2180                            long.class, java.lang.String.class
2181                    };
2182            private static final Class<?>[] _getArticleContentParameterTypes13 = new Class[] {
2183                            long.class, java.lang.String.class, double.class,
2184                            java.lang.String.class,
2185                            com.liferay.portal.kernel.portlet.PortletRequestModel.class,
2186                            com.liferay.portal.theme.ThemeDisplay.class
2187                    };
2188            private static final Class<?>[] _getArticleContentParameterTypes14 = new Class[] {
2189                            long.class, java.lang.String.class, double.class,
2190                            java.lang.String.class, com.liferay.portal.theme.ThemeDisplay.class
2191                    };
2192            private static final Class<?>[] _getArticleContentParameterTypes15 = new Class[] {
2193                            long.class, java.lang.String.class, java.lang.String.class,
2194                            com.liferay.portal.kernel.portlet.PortletRequestModel.class,
2195                            com.liferay.portal.theme.ThemeDisplay.class
2196                    };
2197            private static final Class<?>[] _getArticleContentParameterTypes16 = new Class[] {
2198                            long.class, java.lang.String.class, java.lang.String.class,
2199                            com.liferay.portal.theme.ThemeDisplay.class
2200                    };
2201            private static final Class<?>[] _getArticlesParameterTypes17 = new Class[] {
2202                            long.class, long.class
2203                    };
2204            private static final Class<?>[] _getArticlesParameterTypes18 = new Class[] {
2205                            long.class, long.class, int.class, int.class,
2206                            com.liferay.portal.kernel.util.OrderByComparator.class
2207                    };
2208            private static final Class<?>[] _getArticlesByArticleIdParameterTypes19 = new Class[] {
2209                            long.class, java.lang.String.class, int.class, int.class,
2210                            com.liferay.portal.kernel.util.OrderByComparator.class
2211                    };
2212            private static final Class<?>[] _getArticlesByLayoutUuidParameterTypes20 = new Class[] {
2213                            long.class, java.lang.String.class
2214                    };
2215            private static final Class<?>[] _getArticlesByStructureIdParameterTypes21 = new Class[] {
2216                            long.class, long.class, java.lang.String.class, int.class, int.class,
2217                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
2218                    };
2219            private static final Class<?>[] _getArticlesByStructureIdParameterTypes22 = new Class[] {
2220                            long.class, java.lang.String.class, int.class, int.class,
2221                            com.liferay.portal.kernel.util.OrderByComparator.class
2222                    };
2223            private static final Class<?>[] _getArticlesCountParameterTypes23 = new Class[] {
2224                            long.class, long.class
2225                    };
2226            private static final Class<?>[] _getArticlesCountParameterTypes24 = new Class[] {
2227                            long.class, long.class, int.class
2228                    };
2229            private static final Class<?>[] _getArticlesCountByArticleIdParameterTypes25 =
2230                    new Class[] { long.class, java.lang.String.class };
2231            private static final Class<?>[] _getArticlesCountByStructureIdParameterTypes26 =
2232                    new Class[] { long.class, long.class, java.lang.String.class, int.class };
2233            private static final Class<?>[] _getArticlesCountByStructureIdParameterTypes27 =
2234                    new Class[] { long.class, java.lang.String.class };
2235            private static final Class<?>[] _getDisplayArticleByUrlTitleParameterTypes28 =
2236                    new Class[] { long.class, java.lang.String.class };
2237            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes29 = new Class[] {
2238                            long.class, java.util.List.class
2239                    };
2240            private static final Class<?>[] _getGroupArticlesParameterTypes30 = new Class[] {
2241                            long.class, long.class, long.class, int.class, int.class, int.class,
2242                            com.liferay.portal.kernel.util.OrderByComparator.class
2243                    };
2244            private static final Class<?>[] _getGroupArticlesParameterTypes31 = new Class[] {
2245                            long.class, long.class, long.class, int.class, int.class,
2246                            com.liferay.portal.kernel.util.OrderByComparator.class
2247                    };
2248            private static final Class<?>[] _getGroupArticlesCountParameterTypes32 = new Class[] {
2249                            long.class, long.class, long.class
2250                    };
2251            private static final Class<?>[] _getGroupArticlesCountParameterTypes33 = new Class[] {
2252                            long.class, long.class, long.class, int.class
2253                    };
2254            private static final Class<?>[] _getLatestArticleParameterTypes34 = new Class[] {
2255                            long.class
2256                    };
2257            private static final Class<?>[] _getLatestArticleParameterTypes35 = new Class[] {
2258                            long.class, java.lang.String.class, int.class
2259                    };
2260            private static final Class<?>[] _getLatestArticleParameterTypes36 = new Class[] {
2261                            long.class, java.lang.String.class, long.class
2262                    };
2263            private static final Class<?>[] _moveArticleParameterTypes37 = new Class[] {
2264                            long.class, java.lang.String.class, long.class
2265                    };
2266            private static final Class<?>[] _moveArticleParameterTypes38 = new Class[] {
2267                            long.class, java.lang.String.class, long.class,
2268                            com.liferay.portal.service.ServiceContext.class
2269                    };
2270            private static final Class<?>[] _moveArticleFromTrashParameterTypes39 = new Class[] {
2271                            long.class, long.class, long.class,
2272                            com.liferay.portal.service.ServiceContext.class
2273                    };
2274            private static final Class<?>[] _moveArticleFromTrashParameterTypes40 = new Class[] {
2275                            long.class, java.lang.String.class, long.class,
2276                            com.liferay.portal.service.ServiceContext.class
2277                    };
2278            private static final Class<?>[] _moveArticleToTrashParameterTypes41 = new Class[] {
2279                            long.class, java.lang.String.class
2280                    };
2281            private static final Class<?>[] _removeArticleLocaleParameterTypes42 = new Class[] {
2282                            long.class, java.lang.String.class
2283                    };
2284            private static final Class<?>[] _removeArticleLocaleParameterTypes43 = new Class[] {
2285                            long.class, java.lang.String.class, double.class,
2286                            java.lang.String.class
2287                    };
2288            private static final Class<?>[] _restoreArticleFromTrashParameterTypes44 = new Class[] {
2289                            long.class
2290                    };
2291            private static final Class<?>[] _restoreArticleFromTrashParameterTypes45 = new Class[] {
2292                            long.class, java.lang.String.class
2293                    };
2294            private static final Class<?>[] _searchParameterTypes46 = new Class[] {
2295                            long.class, long.class, int.class, int.class, int.class
2296                    };
2297            private static final Class<?>[] _searchParameterTypes47 = new Class[] {
2298                            long.class, long.class, java.util.List.class, long.class,
2299                            java.lang.String.class, java.lang.Double.class,
2300                            java.lang.String.class, java.lang.String.class, java.util.Date.class,
2301                            java.util.Date.class, int.class, java.util.Date.class, int.class,
2302                            int.class, com.liferay.portal.kernel.util.OrderByComparator.class
2303                    };
2304            private static final Class<?>[] _searchParameterTypes48 = new Class[] {
2305                            long.class, long.class, java.util.List.class, long.class,
2306                            java.lang.String.class, java.lang.Double.class,
2307                            java.lang.String.class, java.lang.String.class,
2308                            java.lang.String.class, java.lang.String.class,
2309                            java.lang.String.class, java.util.Date.class, java.util.Date.class,
2310                            int.class, java.util.Date.class, boolean.class, int.class, int.class,
2311                            com.liferay.portal.kernel.util.OrderByComparator.class
2312                    };
2313            private static final Class<?>[] _searchParameterTypes49 = new Class[] {
2314                            long.class, long.class, java.util.List.class, long.class,
2315                            java.lang.String.class, java.lang.Double.class,
2316                            java.lang.String.class, java.lang.String.class,
2317                            java.lang.String.class, java.lang.String[].class,
2318                            java.lang.String[].class, java.util.Date.class, java.util.Date.class,
2319                            int.class, java.util.Date.class, boolean.class, int.class, int.class,
2320                            com.liferay.portal.kernel.util.OrderByComparator.class
2321                    };
2322            private static final Class<?>[] _searchCountParameterTypes50 = new Class[] {
2323                            long.class, long.class, java.util.List.class, long.class,
2324                            java.lang.String.class, java.lang.Double.class,
2325                            java.lang.String.class, java.lang.String.class, java.util.Date.class,
2326                            java.util.Date.class, int.class, java.util.Date.class
2327                    };
2328            private static final Class<?>[] _searchCountParameterTypes51 = new Class[] {
2329                            long.class, long.class, java.util.List.class, long.class,
2330                            java.lang.String.class, java.lang.Double.class,
2331                            java.lang.String.class, java.lang.String.class,
2332                            java.lang.String.class, java.lang.String.class,
2333                            java.lang.String.class, java.util.Date.class, java.util.Date.class,
2334                            int.class, java.util.Date.class, boolean.class
2335                    };
2336            private static final Class<?>[] _searchCountParameterTypes52 = new Class[] {
2337                            long.class, long.class, java.util.List.class, long.class,
2338                            java.lang.String.class, java.lang.Double.class,
2339                            java.lang.String.class, java.lang.String.class,
2340                            java.lang.String.class, java.lang.String[].class,
2341                            java.lang.String[].class, java.util.Date.class, java.util.Date.class,
2342                            int.class, java.util.Date.class, boolean.class
2343                    };
2344            private static final Class<?>[] _subscribeStructureParameterTypes53 = new Class[] {
2345                            long.class, long.class, long.class
2346                    };
2347            private static final Class<?>[] _unsubscribeStructureParameterTypes54 = new Class[] {
2348                            long.class, long.class, long.class
2349                    };
2350            private static final Class<?>[] _updateArticleParameterTypes55 = new Class[] {
2351                            long.class, long.class, long.class, java.lang.String.class,
2352                            double.class, java.util.Map.class, java.util.Map.class,
2353                            java.lang.String.class, java.lang.String.class,
2354                            com.liferay.portal.service.ServiceContext.class
2355                    };
2356            private static final Class<?>[] _updateArticleParameterTypes56 = new Class[] {
2357                            long.class, long.class, java.lang.String.class, double.class,
2358                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2359                            java.lang.String.class, java.lang.String.class,
2360                            java.lang.String.class, int.class, int.class, int.class, int.class,
2361                            int.class, int.class, int.class, int.class, int.class, int.class,
2362                            boolean.class, int.class, int.class, int.class, int.class, int.class,
2363                            boolean.class, boolean.class, boolean.class, java.lang.String.class,
2364                            java.io.File.class, java.util.Map.class, java.lang.String.class,
2365                            com.liferay.portal.service.ServiceContext.class
2366                    };
2367            private static final Class<?>[] _updateArticleParameterTypes57 = new Class[] {
2368                            long.class, long.class, java.lang.String.class, double.class,
2369                            java.lang.String.class,
2370                            com.liferay.portal.service.ServiceContext.class
2371                    };
2372            private static final Class<?>[] _updateArticleTranslationParameterTypes58 = new Class[] {
2373                            long.class, java.lang.String.class, double.class,
2374                            java.util.Locale.class, java.lang.String.class,
2375                            java.lang.String.class, java.lang.String.class, java.util.Map.class
2376                    };
2377            private static final Class<?>[] _updateArticleTranslationParameterTypes59 = new Class[] {
2378                            long.class, java.lang.String.class, double.class,
2379                            java.util.Locale.class, java.lang.String.class,
2380                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2381                            com.liferay.portal.service.ServiceContext.class
2382                    };
2383            private static final Class<?>[] _updateContentParameterTypes60 = new Class[] {
2384                            long.class, java.lang.String.class, double.class,
2385                            java.lang.String.class
2386                    };
2387            private static final Class<?>[] _updateStatusParameterTypes61 = new Class[] {
2388                            long.class, java.lang.String.class, double.class, int.class,
2389                            java.lang.String.class,
2390                            com.liferay.portal.service.ServiceContext.class
2391                    };
2392    }