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.JournalFolderServiceUtil;
027    
028    /**
029     * Provides the HTTP utility for the
030     * {@link com.liferay.portlet.journal.service.JournalFolderServiceUtil} service utility. The
031     * static methods of this class calls the same methods of the service utility.
032     * However, the signatures are different because it requires an additional
033     * {@link com.liferay.portal.security.auth.HttpPrincipal} parameter.
034     *
035     * <p>
036     * The benefits of using the HTTP utility is that it is fast and allows for
037     * tunneling without the cost of serializing to text. The drawback is that it
038     * only works with Java.
039     * </p>
040     *
041     * <p>
042     * Set the property <b>tunnel.servlet.hosts.allowed</b> in portal.properties to
043     * configure security.
044     * </p>
045     *
046     * <p>
047     * The HTTP utility is only generated for remote services.
048     * </p>
049     *
050     * @author Brian Wing Shun Chan
051     * @see JournalFolderServiceSoap
052     * @see com.liferay.portal.security.auth.HttpPrincipal
053     * @see com.liferay.portlet.journal.service.JournalFolderServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class JournalFolderServiceHttp {
058            public static com.liferay.portlet.journal.model.JournalFolder addFolder(
059                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
060                    java.lang.String name, java.lang.String description,
061                    com.liferay.portal.service.ServiceContext serviceContext)
062                    throws com.liferay.portal.kernel.exception.PortalException {
063                    try {
064                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
065                                            "addFolder", _addFolderParameterTypes0);
066    
067                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
068                                            parentFolderId, name, description, serviceContext);
069    
070                            Object returnObj = null;
071    
072                            try {
073                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
074                            }
075                            catch (Exception e) {
076                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
077                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
078                                    }
079    
080                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
081                            }
082    
083                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
084                    }
085                    catch (com.liferay.portal.kernel.exception.SystemException se) {
086                            _log.error(se, se);
087    
088                            throw se;
089                    }
090            }
091    
092            public static void deleteFolder(HttpPrincipal httpPrincipal, long folderId)
093                    throws com.liferay.portal.kernel.exception.PortalException {
094                    try {
095                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
096                                            "deleteFolder", _deleteFolderParameterTypes1);
097    
098                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
099    
100                            try {
101                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
102                            }
103                            catch (Exception e) {
104                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
105                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
106                                    }
107    
108                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
109                            }
110                    }
111                    catch (com.liferay.portal.kernel.exception.SystemException se) {
112                            _log.error(se, se);
113    
114                            throw se;
115                    }
116            }
117    
118            public static void deleteFolder(HttpPrincipal httpPrincipal, long folderId,
119                    boolean includeTrashedEntries)
120                    throws com.liferay.portal.kernel.exception.PortalException {
121                    try {
122                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
123                                            "deleteFolder", _deleteFolderParameterTypes2);
124    
125                            MethodHandler methodHandler = new MethodHandler(methodKey,
126                                            folderId, includeTrashedEntries);
127    
128                            try {
129                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
130                            }
131                            catch (Exception e) {
132                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
133                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
134                                    }
135    
136                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
137                            }
138                    }
139                    catch (com.liferay.portal.kernel.exception.SystemException se) {
140                            _log.error(se, se);
141    
142                            throw se;
143                    }
144            }
145    
146            public static com.liferay.portlet.journal.model.JournalFolder fetchFolder(
147                    HttpPrincipal httpPrincipal, long folderId)
148                    throws com.liferay.portal.kernel.exception.PortalException {
149                    try {
150                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
151                                            "fetchFolder", _fetchFolderParameterTypes3);
152    
153                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
154    
155                            Object returnObj = null;
156    
157                            try {
158                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
159                            }
160                            catch (Exception e) {
161                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
162                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
163                                    }
164    
165                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
166                            }
167    
168                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
169                    }
170                    catch (com.liferay.portal.kernel.exception.SystemException se) {
171                            _log.error(se, se);
172    
173                            throw se;
174                    }
175            }
176    
177            public static com.liferay.portlet.journal.model.JournalFolder getFolder(
178                    HttpPrincipal httpPrincipal, long folderId)
179                    throws com.liferay.portal.kernel.exception.PortalException {
180                    try {
181                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
182                                            "getFolder", _getFolderParameterTypes4);
183    
184                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
185    
186                            Object returnObj = null;
187    
188                            try {
189                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
190                            }
191                            catch (Exception e) {
192                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
193                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
194                                    }
195    
196                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
197                            }
198    
199                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
200                    }
201                    catch (com.liferay.portal.kernel.exception.SystemException se) {
202                            _log.error(se, se);
203    
204                            throw se;
205                    }
206            }
207    
208            public static java.util.List<java.lang.Long> getFolderIds(
209                    HttpPrincipal httpPrincipal, long groupId, long folderId)
210                    throws com.liferay.portal.kernel.exception.PortalException {
211                    try {
212                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
213                                            "getFolderIds", _getFolderIdsParameterTypes5);
214    
215                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
216                                            folderId);
217    
218                            Object returnObj = null;
219    
220                            try {
221                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
222                            }
223                            catch (Exception e) {
224                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
225                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
226                                    }
227    
228                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
229                            }
230    
231                            return (java.util.List<java.lang.Long>)returnObj;
232                    }
233                    catch (com.liferay.portal.kernel.exception.SystemException se) {
234                            _log.error(se, se);
235    
236                            throw se;
237                    }
238            }
239    
240            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
241                    HttpPrincipal httpPrincipal, long groupId) {
242                    try {
243                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
244                                            "getFolders", _getFoldersParameterTypes6);
245    
246                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId);
247    
248                            Object returnObj = null;
249    
250                            try {
251                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
252                            }
253                            catch (Exception e) {
254                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
255                            }
256    
257                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
258                    }
259                    catch (com.liferay.portal.kernel.exception.SystemException se) {
260                            _log.error(se, se);
261    
262                            throw se;
263                    }
264            }
265    
266            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
267                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId) {
268                    try {
269                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
270                                            "getFolders", _getFoldersParameterTypes7);
271    
272                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
273                                            parentFolderId);
274    
275                            Object returnObj = null;
276    
277                            try {
278                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
279                            }
280                            catch (Exception e) {
281                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
282                            }
283    
284                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
285                    }
286                    catch (com.liferay.portal.kernel.exception.SystemException se) {
287                            _log.error(se, se);
288    
289                            throw se;
290                    }
291            }
292    
293            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
294                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
295                    int status) {
296                    try {
297                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
298                                            "getFolders", _getFoldersParameterTypes8);
299    
300                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
301                                            parentFolderId, status);
302    
303                            Object returnObj = null;
304    
305                            try {
306                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
307                            }
308                            catch (Exception e) {
309                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
310                            }
311    
312                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
313                    }
314                    catch (com.liferay.portal.kernel.exception.SystemException se) {
315                            _log.error(se, se);
316    
317                            throw se;
318                    }
319            }
320    
321            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
322                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
323                    int start, int end) {
324                    try {
325                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
326                                            "getFolders", _getFoldersParameterTypes9);
327    
328                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
329                                            parentFolderId, start, end);
330    
331                            Object returnObj = null;
332    
333                            try {
334                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
335                            }
336                            catch (Exception e) {
337                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
338                            }
339    
340                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
341                    }
342                    catch (com.liferay.portal.kernel.exception.SystemException se) {
343                            _log.error(se, se);
344    
345                            throw se;
346                    }
347            }
348    
349            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
350                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
351                    int status, int start, int end) {
352                    try {
353                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
354                                            "getFolders", _getFoldersParameterTypes10);
355    
356                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
357                                            parentFolderId, status, start, end);
358    
359                            Object returnObj = null;
360    
361                            try {
362                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
363                            }
364                            catch (Exception e) {
365                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
366                            }
367    
368                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
369                    }
370                    catch (com.liferay.portal.kernel.exception.SystemException se) {
371                            _log.error(se, se);
372    
373                            throw se;
374                    }
375            }
376    
377            public static java.util.List<java.lang.Object> getFoldersAndArticles(
378                    HttpPrincipal httpPrincipal, long groupId, long folderId, int status,
379                    int start, int end,
380                    com.liferay.portal.kernel.util.OrderByComparator<?> obc) {
381                    try {
382                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
383                                            "getFoldersAndArticles",
384                                            _getFoldersAndArticlesParameterTypes11);
385    
386                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
387                                            folderId, status, start, end, obc);
388    
389                            Object returnObj = null;
390    
391                            try {
392                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
393                            }
394                            catch (Exception e) {
395                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
396                            }
397    
398                            return (java.util.List<java.lang.Object>)returnObj;
399                    }
400                    catch (com.liferay.portal.kernel.exception.SystemException se) {
401                            _log.error(se, se);
402    
403                            throw se;
404                    }
405            }
406    
407            public static java.util.List<java.lang.Object> getFoldersAndArticles(
408                    HttpPrincipal httpPrincipal, long groupId, long folderId, int start,
409                    int end, com.liferay.portal.kernel.util.OrderByComparator<?> obc) {
410                    try {
411                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
412                                            "getFoldersAndArticles",
413                                            _getFoldersAndArticlesParameterTypes12);
414    
415                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
416                                            folderId, start, end, obc);
417    
418                            Object returnObj = null;
419    
420                            try {
421                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
422                            }
423                            catch (Exception e) {
424                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
425                            }
426    
427                            return (java.util.List<java.lang.Object>)returnObj;
428                    }
429                    catch (com.liferay.portal.kernel.exception.SystemException se) {
430                            _log.error(se, se);
431    
432                            throw se;
433                    }
434            }
435    
436            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
437                    long groupId, java.util.List<java.lang.Long> folderIds, int status) {
438                    try {
439                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
440                                            "getFoldersAndArticlesCount",
441                                            _getFoldersAndArticlesCountParameterTypes13);
442    
443                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
444                                            folderIds, status);
445    
446                            Object returnObj = null;
447    
448                            try {
449                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
450                            }
451                            catch (Exception e) {
452                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
453                            }
454    
455                            return ((Integer)returnObj).intValue();
456                    }
457                    catch (com.liferay.portal.kernel.exception.SystemException se) {
458                            _log.error(se, se);
459    
460                            throw se;
461                    }
462            }
463    
464            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
465                    long groupId, long folderId) {
466                    try {
467                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
468                                            "getFoldersAndArticlesCount",
469                                            _getFoldersAndArticlesCountParameterTypes14);
470    
471                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
472                                            folderId);
473    
474                            Object returnObj = null;
475    
476                            try {
477                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
478                            }
479                            catch (Exception e) {
480                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
481                            }
482    
483                            return ((Integer)returnObj).intValue();
484                    }
485                    catch (com.liferay.portal.kernel.exception.SystemException se) {
486                            _log.error(se, se);
487    
488                            throw se;
489                    }
490            }
491    
492            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
493                    long groupId, long folderId, int status) {
494                    try {
495                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
496                                            "getFoldersAndArticlesCount",
497                                            _getFoldersAndArticlesCountParameterTypes15);
498    
499                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
500                                            folderId, status);
501    
502                            Object returnObj = null;
503    
504                            try {
505                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
506                            }
507                            catch (Exception e) {
508                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
509                            }
510    
511                            return ((Integer)returnObj).intValue();
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 int getFoldersCount(HttpPrincipal httpPrincipal,
521                    long groupId, long parentFolderId) {
522                    try {
523                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
524                                            "getFoldersCount", _getFoldersCountParameterTypes16);
525    
526                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
527                                            parentFolderId);
528    
529                            Object returnObj = null;
530    
531                            try {
532                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
533                            }
534                            catch (Exception e) {
535                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
536                            }
537    
538                            return ((Integer)returnObj).intValue();
539                    }
540                    catch (com.liferay.portal.kernel.exception.SystemException se) {
541                            _log.error(se, se);
542    
543                            throw se;
544                    }
545            }
546    
547            public static int getFoldersCount(HttpPrincipal httpPrincipal,
548                    long groupId, long parentFolderId, int status) {
549                    try {
550                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
551                                            "getFoldersCount", _getFoldersCountParameterTypes17);
552    
553                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
554                                            parentFolderId, status);
555    
556                            Object returnObj = null;
557    
558                            try {
559                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
560                            }
561                            catch (Exception e) {
562                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
563                            }
564    
565                            return ((Integer)returnObj).intValue();
566                    }
567                    catch (com.liferay.portal.kernel.exception.SystemException se) {
568                            _log.error(se, se);
569    
570                            throw se;
571                    }
572            }
573    
574            public static void getSubfolderIds(HttpPrincipal httpPrincipal,
575                    java.util.List<java.lang.Long> folderIds, long groupId, long folderId) {
576                    try {
577                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
578                                            "getSubfolderIds", _getSubfolderIdsParameterTypes18);
579    
580                            MethodHandler methodHandler = new MethodHandler(methodKey,
581                                            folderIds, groupId, folderId);
582    
583                            try {
584                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
585                            }
586                            catch (Exception e) {
587                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
588                            }
589                    }
590                    catch (com.liferay.portal.kernel.exception.SystemException se) {
591                            _log.error(se, se);
592    
593                            throw se;
594                    }
595            }
596    
597            public static void getSubfolderIds(HttpPrincipal httpPrincipal,
598                    java.util.List<java.lang.Long> folderIds, long groupId, long folderId,
599                    boolean recurse) {
600                    try {
601                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
602                                            "getSubfolderIds", _getSubfolderIdsParameterTypes19);
603    
604                            MethodHandler methodHandler = new MethodHandler(methodKey,
605                                            folderIds, groupId, folderId, recurse);
606    
607                            try {
608                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
609                            }
610                            catch (Exception e) {
611                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
612                            }
613                    }
614                    catch (com.liferay.portal.kernel.exception.SystemException se) {
615                            _log.error(se, se);
616    
617                            throw se;
618                    }
619            }
620    
621            public static java.util.List<java.lang.Long> getSubfolderIds(
622                    HttpPrincipal httpPrincipal, long groupId, long folderId,
623                    boolean recurse) {
624                    try {
625                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
626                                            "getSubfolderIds", _getSubfolderIdsParameterTypes20);
627    
628                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
629                                            folderId, recurse);
630    
631                            Object returnObj = null;
632    
633                            try {
634                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
635                            }
636                            catch (Exception e) {
637                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
638                            }
639    
640                            return (java.util.List<java.lang.Long>)returnObj;
641                    }
642                    catch (com.liferay.portal.kernel.exception.SystemException se) {
643                            _log.error(se, se);
644    
645                            throw se;
646                    }
647            }
648    
649            public static com.liferay.portlet.journal.model.JournalFolder moveFolder(
650                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
651                    com.liferay.portal.service.ServiceContext serviceContext)
652                    throws com.liferay.portal.kernel.exception.PortalException {
653                    try {
654                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
655                                            "moveFolder", _moveFolderParameterTypes21);
656    
657                            MethodHandler methodHandler = new MethodHandler(methodKey,
658                                            folderId, parentFolderId, serviceContext);
659    
660                            Object returnObj = null;
661    
662                            try {
663                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
664                            }
665                            catch (Exception e) {
666                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
667                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
668                                    }
669    
670                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
671                            }
672    
673                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
674                    }
675                    catch (com.liferay.portal.kernel.exception.SystemException se) {
676                            _log.error(se, se);
677    
678                            throw se;
679                    }
680            }
681    
682            public static com.liferay.portlet.journal.model.JournalFolder moveFolderFromTrash(
683                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
684                    com.liferay.portal.service.ServiceContext serviceContext)
685                    throws com.liferay.portal.kernel.exception.PortalException {
686                    try {
687                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
688                                            "moveFolderFromTrash", _moveFolderFromTrashParameterTypes22);
689    
690                            MethodHandler methodHandler = new MethodHandler(methodKey,
691                                            folderId, parentFolderId, serviceContext);
692    
693                            Object returnObj = null;
694    
695                            try {
696                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
697                            }
698                            catch (Exception e) {
699                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
700                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
701                                    }
702    
703                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
704                            }
705    
706                            return (com.liferay.portlet.journal.model.JournalFolder)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 com.liferay.portlet.journal.model.JournalFolder moveFolderToTrash(
716                    HttpPrincipal httpPrincipal, long folderId)
717                    throws com.liferay.portal.kernel.exception.PortalException {
718                    try {
719                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
720                                            "moveFolderToTrash", _moveFolderToTrashParameterTypes23);
721    
722                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
723    
724                            Object returnObj = null;
725    
726                            try {
727                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
728                            }
729                            catch (Exception e) {
730                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
731                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
732                                    }
733    
734                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
735                            }
736    
737                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
738                    }
739                    catch (com.liferay.portal.kernel.exception.SystemException se) {
740                            _log.error(se, se);
741    
742                            throw se;
743                    }
744            }
745    
746            public static void restoreFolderFromTrash(HttpPrincipal httpPrincipal,
747                    long folderId)
748                    throws com.liferay.portal.kernel.exception.PortalException {
749                    try {
750                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
751                                            "restoreFolderFromTrash",
752                                            _restoreFolderFromTrashParameterTypes24);
753    
754                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
755    
756                            try {
757                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
758                            }
759                            catch (Exception e) {
760                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
761                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
762                                    }
763    
764                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
765                            }
766                    }
767                    catch (com.liferay.portal.kernel.exception.SystemException se) {
768                            _log.error(se, se);
769    
770                            throw se;
771                    }
772            }
773    
774            public static void subscribe(HttpPrincipal httpPrincipal, long groupId,
775                    long folderId)
776                    throws com.liferay.portal.kernel.exception.PortalException {
777                    try {
778                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
779                                            "subscribe", _subscribeParameterTypes25);
780    
781                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
782                                            folderId);
783    
784                            try {
785                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
786                            }
787                            catch (Exception e) {
788                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
789                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
790                                    }
791    
792                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
793                            }
794                    }
795                    catch (com.liferay.portal.kernel.exception.SystemException se) {
796                            _log.error(se, se);
797    
798                            throw se;
799                    }
800            }
801    
802            public static void unsubscribe(HttpPrincipal httpPrincipal, long groupId,
803                    long folderId)
804                    throws com.liferay.portal.kernel.exception.PortalException {
805                    try {
806                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
807                                            "unsubscribe", _unsubscribeParameterTypes26);
808    
809                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
810                                            folderId);
811    
812                            try {
813                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
814                            }
815                            catch (Exception e) {
816                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
817                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
818                                    }
819    
820                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
821                            }
822                    }
823                    catch (com.liferay.portal.kernel.exception.SystemException se) {
824                            _log.error(se, se);
825    
826                            throw se;
827                    }
828            }
829    
830            public static com.liferay.portlet.journal.model.JournalFolder updateFolder(
831                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
832                    java.lang.String name, java.lang.String description,
833                    boolean mergeWithParentFolder,
834                    com.liferay.portal.service.ServiceContext serviceContext)
835                    throws com.liferay.portal.kernel.exception.PortalException {
836                    try {
837                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
838                                            "updateFolder", _updateFolderParameterTypes27);
839    
840                            MethodHandler methodHandler = new MethodHandler(methodKey,
841                                            folderId, parentFolderId, name, description,
842                                            mergeWithParentFolder, serviceContext);
843    
844                            Object returnObj = null;
845    
846                            try {
847                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
848                            }
849                            catch (Exception e) {
850                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
851                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
852                                    }
853    
854                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
855                            }
856    
857                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
858                    }
859                    catch (com.liferay.portal.kernel.exception.SystemException se) {
860                            _log.error(se, se);
861    
862                            throw se;
863                    }
864            }
865    
866            public static com.liferay.portlet.journal.model.JournalFolder updateFolder(
867                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
868                    java.lang.String name, java.lang.String description,
869                    long[] ddmStructureIds, int restrictionType,
870                    boolean mergeWithParentFolder,
871                    com.liferay.portal.service.ServiceContext serviceContext)
872                    throws com.liferay.portal.kernel.exception.PortalException {
873                    try {
874                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
875                                            "updateFolder", _updateFolderParameterTypes28);
876    
877                            MethodHandler methodHandler = new MethodHandler(methodKey,
878                                            folderId, parentFolderId, name, description,
879                                            ddmStructureIds, restrictionType, mergeWithParentFolder,
880                                            serviceContext);
881    
882                            Object returnObj = null;
883    
884                            try {
885                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
886                            }
887                            catch (Exception e) {
888                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
889                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
890                                    }
891    
892                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
893                            }
894    
895                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
896                    }
897                    catch (com.liferay.portal.kernel.exception.SystemException se) {
898                            _log.error(se, se);
899    
900                            throw se;
901                    }
902            }
903    
904            private static Log _log = LogFactoryUtil.getLog(JournalFolderServiceHttp.class);
905            private static final Class<?>[] _addFolderParameterTypes0 = new Class[] {
906                            long.class, long.class, java.lang.String.class,
907                            java.lang.String.class,
908                            com.liferay.portal.service.ServiceContext.class
909                    };
910            private static final Class<?>[] _deleteFolderParameterTypes1 = new Class[] {
911                            long.class
912                    };
913            private static final Class<?>[] _deleteFolderParameterTypes2 = new Class[] {
914                            long.class, boolean.class
915                    };
916            private static final Class<?>[] _fetchFolderParameterTypes3 = new Class[] {
917                            long.class
918                    };
919            private static final Class<?>[] _getFolderParameterTypes4 = new Class[] {
920                            long.class
921                    };
922            private static final Class<?>[] _getFolderIdsParameterTypes5 = new Class[] {
923                            long.class, long.class
924                    };
925            private static final Class<?>[] _getFoldersParameterTypes6 = new Class[] {
926                            long.class
927                    };
928            private static final Class<?>[] _getFoldersParameterTypes7 = new Class[] {
929                            long.class, long.class
930                    };
931            private static final Class<?>[] _getFoldersParameterTypes8 = new Class[] {
932                            long.class, long.class, int.class
933                    };
934            private static final Class<?>[] _getFoldersParameterTypes9 = new Class[] {
935                            long.class, long.class, int.class, int.class
936                    };
937            private static final Class<?>[] _getFoldersParameterTypes10 = new Class[] {
938                            long.class, long.class, int.class, int.class, int.class
939                    };
940            private static final Class<?>[] _getFoldersAndArticlesParameterTypes11 = new Class[] {
941                            long.class, long.class, int.class, int.class, int.class,
942                            com.liferay.portal.kernel.util.OrderByComparator.class
943                    };
944            private static final Class<?>[] _getFoldersAndArticlesParameterTypes12 = new Class[] {
945                            long.class, long.class, int.class, int.class,
946                            com.liferay.portal.kernel.util.OrderByComparator.class
947                    };
948            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes13 = new Class[] {
949                            long.class, java.util.List.class, int.class
950                    };
951            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes14 = new Class[] {
952                            long.class, long.class
953                    };
954            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes15 = new Class[] {
955                            long.class, long.class, int.class
956                    };
957            private static final Class<?>[] _getFoldersCountParameterTypes16 = new Class[] {
958                            long.class, long.class
959                    };
960            private static final Class<?>[] _getFoldersCountParameterTypes17 = new Class[] {
961                            long.class, long.class, int.class
962                    };
963            private static final Class<?>[] _getSubfolderIdsParameterTypes18 = new Class[] {
964                            java.util.List.class, long.class, long.class
965                    };
966            private static final Class<?>[] _getSubfolderIdsParameterTypes19 = new Class[] {
967                            java.util.List.class, long.class, long.class, boolean.class
968                    };
969            private static final Class<?>[] _getSubfolderIdsParameterTypes20 = new Class[] {
970                            long.class, long.class, boolean.class
971                    };
972            private static final Class<?>[] _moveFolderParameterTypes21 = new Class[] {
973                            long.class, long.class,
974                            com.liferay.portal.service.ServiceContext.class
975                    };
976            private static final Class<?>[] _moveFolderFromTrashParameterTypes22 = new Class[] {
977                            long.class, long.class,
978                            com.liferay.portal.service.ServiceContext.class
979                    };
980            private static final Class<?>[] _moveFolderToTrashParameterTypes23 = new Class[] {
981                            long.class
982                    };
983            private static final Class<?>[] _restoreFolderFromTrashParameterTypes24 = new Class[] {
984                            long.class
985                    };
986            private static final Class<?>[] _subscribeParameterTypes25 = new Class[] {
987                            long.class, long.class
988                    };
989            private static final Class<?>[] _unsubscribeParameterTypes26 = new Class[] {
990                            long.class, long.class
991                    };
992            private static final Class<?>[] _updateFolderParameterTypes27 = new Class[] {
993                            long.class, long.class, java.lang.String.class,
994                            java.lang.String.class, boolean.class,
995                            com.liferay.portal.service.ServiceContext.class
996                    };
997            private static final Class<?>[] _updateFolderParameterTypes28 = new Class[] {
998                            long.class, long.class, java.lang.String.class,
999                            java.lang.String.class, long[].class, int.class, boolean.class,
1000                            com.liferay.portal.service.ServiceContext.class
1001                    };
1002    }