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 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 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 HttpPrincipal
053     * @see 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 java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
178                    HttpPrincipal httpPrincipal, long[] groupIds, long folderId,
179                    int restrictionType)
180                    throws com.liferay.portal.kernel.exception.PortalException {
181                    try {
182                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
183                                            "getDDMStructures", _getDDMStructuresParameterTypes4);
184    
185                            MethodHandler methodHandler = new MethodHandler(methodKey,
186                                            groupIds, folderId, restrictionType);
187    
188                            Object returnObj = null;
189    
190                            try {
191                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
192                            }
193                            catch (Exception e) {
194                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
195                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
196                                    }
197    
198                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
199                            }
200    
201                            return (java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure>)returnObj;
202                    }
203                    catch (com.liferay.portal.kernel.exception.SystemException se) {
204                            _log.error(se, se);
205    
206                            throw se;
207                    }
208            }
209    
210            public static com.liferay.portlet.journal.model.JournalFolder getFolder(
211                    HttpPrincipal httpPrincipal, long folderId)
212                    throws com.liferay.portal.kernel.exception.PortalException {
213                    try {
214                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
215                                            "getFolder", _getFolderParameterTypes5);
216    
217                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
218    
219                            Object returnObj = null;
220    
221                            try {
222                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
223                            }
224                            catch (Exception e) {
225                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
226                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
227                                    }
228    
229                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
230                            }
231    
232                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
233                    }
234                    catch (com.liferay.portal.kernel.exception.SystemException se) {
235                            _log.error(se, se);
236    
237                            throw se;
238                    }
239            }
240    
241            public static java.util.List<java.lang.Long> getFolderIds(
242                    HttpPrincipal httpPrincipal, long groupId, long folderId)
243                    throws com.liferay.portal.kernel.exception.PortalException {
244                    try {
245                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
246                                            "getFolderIds", _getFolderIdsParameterTypes6);
247    
248                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
249                                            folderId);
250    
251                            Object returnObj = null;
252    
253                            try {
254                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
255                            }
256                            catch (Exception e) {
257                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
258                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
259                                    }
260    
261                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
262                            }
263    
264                            return (java.util.List<java.lang.Long>)returnObj;
265                    }
266                    catch (com.liferay.portal.kernel.exception.SystemException se) {
267                            _log.error(se, se);
268    
269                            throw se;
270                    }
271            }
272    
273            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
274                    HttpPrincipal httpPrincipal, long groupId) {
275                    try {
276                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
277                                            "getFolders", _getFoldersParameterTypes7);
278    
279                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId);
280    
281                            Object returnObj = null;
282    
283                            try {
284                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
285                            }
286                            catch (Exception e) {
287                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
288                            }
289    
290                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
291                    }
292                    catch (com.liferay.portal.kernel.exception.SystemException se) {
293                            _log.error(se, se);
294    
295                            throw se;
296                    }
297            }
298    
299            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
300                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId) {
301                    try {
302                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
303                                            "getFolders", _getFoldersParameterTypes8);
304    
305                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
306                                            parentFolderId);
307    
308                            Object returnObj = null;
309    
310                            try {
311                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
312                            }
313                            catch (Exception e) {
314                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
315                            }
316    
317                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
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 java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
327                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
328                    int status) {
329                    try {
330                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
331                                            "getFolders", _getFoldersParameterTypes9);
332    
333                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
334                                            parentFolderId, status);
335    
336                            Object returnObj = null;
337    
338                            try {
339                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
340                            }
341                            catch (Exception e) {
342                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
343                            }
344    
345                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
346                    }
347                    catch (com.liferay.portal.kernel.exception.SystemException se) {
348                            _log.error(se, se);
349    
350                            throw se;
351                    }
352            }
353    
354            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
355                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
356                    int start, int end) {
357                    try {
358                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
359                                            "getFolders", _getFoldersParameterTypes10);
360    
361                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
362                                            parentFolderId, start, end);
363    
364                            Object returnObj = null;
365    
366                            try {
367                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
368                            }
369                            catch (Exception e) {
370                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
371                            }
372    
373                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
374                    }
375                    catch (com.liferay.portal.kernel.exception.SystemException se) {
376                            _log.error(se, se);
377    
378                            throw se;
379                    }
380            }
381    
382            public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> getFolders(
383                    HttpPrincipal httpPrincipal, long groupId, long parentFolderId,
384                    int status, int start, int end) {
385                    try {
386                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
387                                            "getFolders", _getFoldersParameterTypes11);
388    
389                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
390                                            parentFolderId, status, start, end);
391    
392                            Object returnObj = null;
393    
394                            try {
395                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
396                            }
397                            catch (Exception e) {
398                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
399                            }
400    
401                            return (java.util.List<com.liferay.portlet.journal.model.JournalFolder>)returnObj;
402                    }
403                    catch (com.liferay.portal.kernel.exception.SystemException se) {
404                            _log.error(se, se);
405    
406                            throw se;
407                    }
408            }
409    
410            public static java.util.List<java.lang.Object> getFoldersAndArticles(
411                    HttpPrincipal httpPrincipal, long groupId, long folderId, int status,
412                    int start, int end,
413                    com.liferay.portal.kernel.util.OrderByComparator<?> obc) {
414                    try {
415                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
416                                            "getFoldersAndArticles",
417                                            _getFoldersAndArticlesParameterTypes12);
418    
419                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
420                                            folderId, status, start, end, obc);
421    
422                            Object returnObj = null;
423    
424                            try {
425                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
426                            }
427                            catch (Exception e) {
428                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
429                            }
430    
431                            return (java.util.List<java.lang.Object>)returnObj;
432                    }
433                    catch (com.liferay.portal.kernel.exception.SystemException se) {
434                            _log.error(se, se);
435    
436                            throw se;
437                    }
438            }
439    
440            public static java.util.List<java.lang.Object> getFoldersAndArticles(
441                    HttpPrincipal httpPrincipal, long groupId, long folderId, int start,
442                    int end, com.liferay.portal.kernel.util.OrderByComparator<?> obc) {
443                    try {
444                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
445                                            "getFoldersAndArticles",
446                                            _getFoldersAndArticlesParameterTypes13);
447    
448                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
449                                            folderId, start, end, obc);
450    
451                            Object returnObj = null;
452    
453                            try {
454                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
455                            }
456                            catch (Exception e) {
457                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
458                            }
459    
460                            return (java.util.List<java.lang.Object>)returnObj;
461                    }
462                    catch (com.liferay.portal.kernel.exception.SystemException se) {
463                            _log.error(se, se);
464    
465                            throw se;
466                    }
467            }
468    
469            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
470                    long groupId, java.util.List<java.lang.Long> folderIds, int status) {
471                    try {
472                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
473                                            "getFoldersAndArticlesCount",
474                                            _getFoldersAndArticlesCountParameterTypes14);
475    
476                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
477                                            folderIds, status);
478    
479                            Object returnObj = null;
480    
481                            try {
482                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
483                            }
484                            catch (Exception e) {
485                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
486                            }
487    
488                            return ((Integer)returnObj).intValue();
489                    }
490                    catch (com.liferay.portal.kernel.exception.SystemException se) {
491                            _log.error(se, se);
492    
493                            throw se;
494                    }
495            }
496    
497            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
498                    long groupId, long folderId) {
499                    try {
500                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
501                                            "getFoldersAndArticlesCount",
502                                            _getFoldersAndArticlesCountParameterTypes15);
503    
504                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
505                                            folderId);
506    
507                            Object returnObj = null;
508    
509                            try {
510                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
511                            }
512                            catch (Exception e) {
513                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
514                            }
515    
516                            return ((Integer)returnObj).intValue();
517                    }
518                    catch (com.liferay.portal.kernel.exception.SystemException se) {
519                            _log.error(se, se);
520    
521                            throw se;
522                    }
523            }
524    
525            public static int getFoldersAndArticlesCount(HttpPrincipal httpPrincipal,
526                    long groupId, long folderId, int status) {
527                    try {
528                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
529                                            "getFoldersAndArticlesCount",
530                                            _getFoldersAndArticlesCountParameterTypes16);
531    
532                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
533                                            folderId, status);
534    
535                            Object returnObj = null;
536    
537                            try {
538                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
539                            }
540                            catch (Exception e) {
541                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
542                            }
543    
544                            return ((Integer)returnObj).intValue();
545                    }
546                    catch (com.liferay.portal.kernel.exception.SystemException se) {
547                            _log.error(se, se);
548    
549                            throw se;
550                    }
551            }
552    
553            public static int getFoldersCount(HttpPrincipal httpPrincipal,
554                    long groupId, long parentFolderId) {
555                    try {
556                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
557                                            "getFoldersCount", _getFoldersCountParameterTypes17);
558    
559                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
560                                            parentFolderId);
561    
562                            Object returnObj = null;
563    
564                            try {
565                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
566                            }
567                            catch (Exception e) {
568                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
569                            }
570    
571                            return ((Integer)returnObj).intValue();
572                    }
573                    catch (com.liferay.portal.kernel.exception.SystemException se) {
574                            _log.error(se, se);
575    
576                            throw se;
577                    }
578            }
579    
580            public static int getFoldersCount(HttpPrincipal httpPrincipal,
581                    long groupId, long parentFolderId, int status) {
582                    try {
583                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
584                                            "getFoldersCount", _getFoldersCountParameterTypes18);
585    
586                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
587                                            parentFolderId, status);
588    
589                            Object returnObj = null;
590    
591                            try {
592                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
593                            }
594                            catch (Exception e) {
595                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
596                            }
597    
598                            return ((Integer)returnObj).intValue();
599                    }
600                    catch (com.liferay.portal.kernel.exception.SystemException se) {
601                            _log.error(se, se);
602    
603                            throw se;
604                    }
605            }
606    
607            public static void getSubfolderIds(HttpPrincipal httpPrincipal,
608                    java.util.List<java.lang.Long> folderIds, long groupId, long folderId) {
609                    try {
610                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
611                                            "getSubfolderIds", _getSubfolderIdsParameterTypes19);
612    
613                            MethodHandler methodHandler = new MethodHandler(methodKey,
614                                            folderIds, groupId, folderId);
615    
616                            try {
617                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
618                            }
619                            catch (Exception e) {
620                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
621                            }
622                    }
623                    catch (com.liferay.portal.kernel.exception.SystemException se) {
624                            _log.error(se, se);
625    
626                            throw se;
627                    }
628            }
629    
630            public static void getSubfolderIds(HttpPrincipal httpPrincipal,
631                    java.util.List<java.lang.Long> folderIds, long groupId, long folderId,
632                    boolean recurse) {
633                    try {
634                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
635                                            "getSubfolderIds", _getSubfolderIdsParameterTypes20);
636    
637                            MethodHandler methodHandler = new MethodHandler(methodKey,
638                                            folderIds, groupId, folderId, recurse);
639    
640                            try {
641                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
642                            }
643                            catch (Exception e) {
644                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
645                            }
646                    }
647                    catch (com.liferay.portal.kernel.exception.SystemException se) {
648                            _log.error(se, se);
649    
650                            throw se;
651                    }
652            }
653    
654            public static java.util.List<java.lang.Long> getSubfolderIds(
655                    HttpPrincipal httpPrincipal, long groupId, long folderId,
656                    boolean recurse) {
657                    try {
658                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
659                                            "getSubfolderIds", _getSubfolderIdsParameterTypes21);
660    
661                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
662                                            folderId, recurse);
663    
664                            Object returnObj = null;
665    
666                            try {
667                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
668                            }
669                            catch (Exception e) {
670                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
671                            }
672    
673                            return (java.util.List<java.lang.Long>)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 moveFolder(
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                                            "moveFolder", _moveFolderParameterTypes22);
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 moveFolderFromTrash(
716                    HttpPrincipal httpPrincipal, long folderId, long parentFolderId,
717                    com.liferay.portal.service.ServiceContext serviceContext)
718                    throws com.liferay.portal.kernel.exception.PortalException {
719                    try {
720                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
721                                            "moveFolderFromTrash", _moveFolderFromTrashParameterTypes23);
722    
723                            MethodHandler methodHandler = new MethodHandler(methodKey,
724                                            folderId, parentFolderId, serviceContext);
725    
726                            Object returnObj = null;
727    
728                            try {
729                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
730                            }
731                            catch (Exception e) {
732                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
733                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
734                                    }
735    
736                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
737                            }
738    
739                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
740                    }
741                    catch (com.liferay.portal.kernel.exception.SystemException se) {
742                            _log.error(se, se);
743    
744                            throw se;
745                    }
746            }
747    
748            public static com.liferay.portlet.journal.model.JournalFolder moveFolderToTrash(
749                    HttpPrincipal httpPrincipal, long folderId)
750                    throws com.liferay.portal.kernel.exception.PortalException {
751                    try {
752                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
753                                            "moveFolderToTrash", _moveFolderToTrashParameterTypes24);
754    
755                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
756    
757                            Object returnObj = null;
758    
759                            try {
760                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
761                            }
762                            catch (Exception e) {
763                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
764                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
765                                    }
766    
767                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
768                            }
769    
770                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
771                    }
772                    catch (com.liferay.portal.kernel.exception.SystemException se) {
773                            _log.error(se, se);
774    
775                            throw se;
776                    }
777            }
778    
779            public static void restoreFolderFromTrash(HttpPrincipal httpPrincipal,
780                    long folderId)
781                    throws com.liferay.portal.kernel.exception.PortalException {
782                    try {
783                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
784                                            "restoreFolderFromTrash",
785                                            _restoreFolderFromTrashParameterTypes25);
786    
787                            MethodHandler methodHandler = new MethodHandler(methodKey, folderId);
788    
789                            try {
790                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
791                            }
792                            catch (Exception e) {
793                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
794                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
795                                    }
796    
797                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
798                            }
799                    }
800                    catch (com.liferay.portal.kernel.exception.SystemException se) {
801                            _log.error(se, se);
802    
803                            throw se;
804                    }
805            }
806    
807            public static void subscribe(HttpPrincipal httpPrincipal, long groupId,
808                    long folderId)
809                    throws com.liferay.portal.kernel.exception.PortalException {
810                    try {
811                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
812                                            "subscribe", _subscribeParameterTypes26);
813    
814                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
815                                            folderId);
816    
817                            try {
818                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
819                            }
820                            catch (Exception e) {
821                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
822                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
823                                    }
824    
825                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
826                            }
827                    }
828                    catch (com.liferay.portal.kernel.exception.SystemException se) {
829                            _log.error(se, se);
830    
831                            throw se;
832                    }
833            }
834    
835            public static void unsubscribe(HttpPrincipal httpPrincipal, long groupId,
836                    long folderId)
837                    throws com.liferay.portal.kernel.exception.PortalException {
838                    try {
839                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
840                                            "unsubscribe", _unsubscribeParameterTypes27);
841    
842                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
843                                            folderId);
844    
845                            try {
846                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
847                            }
848                            catch (Exception e) {
849                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
850                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
851                                    }
852    
853                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
854                            }
855                    }
856                    catch (com.liferay.portal.kernel.exception.SystemException se) {
857                            _log.error(se, se);
858    
859                            throw se;
860                    }
861            }
862    
863            public static com.liferay.portlet.journal.model.JournalFolder updateFolder(
864                    HttpPrincipal httpPrincipal, long groupId, long folderId,
865                    long parentFolderId, java.lang.String name,
866                    java.lang.String description, boolean mergeWithParentFolder,
867                    com.liferay.portal.service.ServiceContext serviceContext)
868                    throws com.liferay.portal.kernel.exception.PortalException {
869                    try {
870                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
871                                            "updateFolder", _updateFolderParameterTypes28);
872    
873                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
874                                            folderId, parentFolderId, name, description,
875                                            mergeWithParentFolder, serviceContext);
876    
877                            Object returnObj = null;
878    
879                            try {
880                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
881                            }
882                            catch (Exception e) {
883                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
884                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
885                                    }
886    
887                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
888                            }
889    
890                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
891                    }
892                    catch (com.liferay.portal.kernel.exception.SystemException se) {
893                            _log.error(se, se);
894    
895                            throw se;
896                    }
897            }
898    
899            public static com.liferay.portlet.journal.model.JournalFolder updateFolder(
900                    HttpPrincipal httpPrincipal, long groupId, long folderId,
901                    long parentFolderId, java.lang.String name,
902                    java.lang.String description, long[] ddmStructureIds,
903                    int restrictionType, boolean mergeWithParentFolder,
904                    com.liferay.portal.service.ServiceContext serviceContext)
905                    throws com.liferay.portal.kernel.exception.PortalException {
906                    try {
907                            MethodKey methodKey = new MethodKey(JournalFolderServiceUtil.class,
908                                            "updateFolder", _updateFolderParameterTypes29);
909    
910                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
911                                            folderId, parentFolderId, name, description,
912                                            ddmStructureIds, restrictionType, mergeWithParentFolder,
913                                            serviceContext);
914    
915                            Object returnObj = null;
916    
917                            try {
918                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
919                            }
920                            catch (Exception e) {
921                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
922                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
923                                    }
924    
925                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
926                            }
927    
928                            return (com.liferay.portlet.journal.model.JournalFolder)returnObj;
929                    }
930                    catch (com.liferay.portal.kernel.exception.SystemException se) {
931                            _log.error(se, se);
932    
933                            throw se;
934                    }
935            }
936    
937            private static Log _log = LogFactoryUtil.getLog(JournalFolderServiceHttp.class);
938            private static final Class<?>[] _addFolderParameterTypes0 = new Class[] {
939                            long.class, long.class, java.lang.String.class,
940                            java.lang.String.class,
941                            com.liferay.portal.service.ServiceContext.class
942                    };
943            private static final Class<?>[] _deleteFolderParameterTypes1 = new Class[] {
944                            long.class
945                    };
946            private static final Class<?>[] _deleteFolderParameterTypes2 = new Class[] {
947                            long.class, boolean.class
948                    };
949            private static final Class<?>[] _fetchFolderParameterTypes3 = new Class[] {
950                            long.class
951                    };
952            private static final Class<?>[] _getDDMStructuresParameterTypes4 = new Class[] {
953                            long[].class, long.class, int.class
954                    };
955            private static final Class<?>[] _getFolderParameterTypes5 = new Class[] {
956                            long.class
957                    };
958            private static final Class<?>[] _getFolderIdsParameterTypes6 = new Class[] {
959                            long.class, long.class
960                    };
961            private static final Class<?>[] _getFoldersParameterTypes7 = new Class[] {
962                            long.class
963                    };
964            private static final Class<?>[] _getFoldersParameterTypes8 = new Class[] {
965                            long.class, long.class
966                    };
967            private static final Class<?>[] _getFoldersParameterTypes9 = new Class[] {
968                            long.class, long.class, int.class
969                    };
970            private static final Class<?>[] _getFoldersParameterTypes10 = new Class[] {
971                            long.class, long.class, int.class, int.class
972                    };
973            private static final Class<?>[] _getFoldersParameterTypes11 = new Class[] {
974                            long.class, long.class, int.class, int.class, int.class
975                    };
976            private static final Class<?>[] _getFoldersAndArticlesParameterTypes12 = new Class[] {
977                            long.class, long.class, int.class, int.class, int.class,
978                            com.liferay.portal.kernel.util.OrderByComparator.class
979                    };
980            private static final Class<?>[] _getFoldersAndArticlesParameterTypes13 = new Class[] {
981                            long.class, long.class, int.class, int.class,
982                            com.liferay.portal.kernel.util.OrderByComparator.class
983                    };
984            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes14 = new Class[] {
985                            long.class, java.util.List.class, int.class
986                    };
987            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes15 = new Class[] {
988                            long.class, long.class
989                    };
990            private static final Class<?>[] _getFoldersAndArticlesCountParameterTypes16 = new Class[] {
991                            long.class, long.class, int.class
992                    };
993            private static final Class<?>[] _getFoldersCountParameterTypes17 = new Class[] {
994                            long.class, long.class
995                    };
996            private static final Class<?>[] _getFoldersCountParameterTypes18 = new Class[] {
997                            long.class, long.class, int.class
998                    };
999            private static final Class<?>[] _getSubfolderIdsParameterTypes19 = new Class[] {
1000                            java.util.List.class, long.class, long.class
1001                    };
1002            private static final Class<?>[] _getSubfolderIdsParameterTypes20 = new Class[] {
1003                            java.util.List.class, long.class, long.class, boolean.class
1004                    };
1005            private static final Class<?>[] _getSubfolderIdsParameterTypes21 = new Class[] {
1006                            long.class, long.class, boolean.class
1007                    };
1008            private static final Class<?>[] _moveFolderParameterTypes22 = new Class[] {
1009                            long.class, long.class,
1010                            com.liferay.portal.service.ServiceContext.class
1011                    };
1012            private static final Class<?>[] _moveFolderFromTrashParameterTypes23 = new Class[] {
1013                            long.class, long.class,
1014                            com.liferay.portal.service.ServiceContext.class
1015                    };
1016            private static final Class<?>[] _moveFolderToTrashParameterTypes24 = new Class[] {
1017                            long.class
1018                    };
1019            private static final Class<?>[] _restoreFolderFromTrashParameterTypes25 = new Class[] {
1020                            long.class
1021                    };
1022            private static final Class<?>[] _subscribeParameterTypes26 = new Class[] {
1023                            long.class, long.class
1024                    };
1025            private static final Class<?>[] _unsubscribeParameterTypes27 = new Class[] {
1026                            long.class, long.class
1027                    };
1028            private static final Class<?>[] _updateFolderParameterTypes28 = new Class[] {
1029                            long.class, long.class, long.class, java.lang.String.class,
1030                            java.lang.String.class, boolean.class,
1031                            com.liferay.portal.service.ServiceContext.class
1032                    };
1033            private static final Class<?>[] _updateFolderParameterTypes29 = new Class[] {
1034                            long.class, long.class, long.class, java.lang.String.class,
1035                            java.lang.String.class, long[].class, int.class, boolean.class,
1036                            com.liferay.portal.service.ServiceContext.class
1037                    };
1038    }