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.asset.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.asset.service.AssetVocabularyServiceUtil;
027    
028    /**
029     * Provides the HTTP utility for the
030     * {@link com.liferay.portlet.asset.service.AssetVocabularyServiceUtil} 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 AssetVocabularyServiceSoap
052     * @see com.liferay.portal.security.auth.HttpPrincipal
053     * @see com.liferay.portlet.asset.service.AssetVocabularyServiceUtil
054     * @generated
055     */
056    @ProviderType
057    public class AssetVocabularyServiceHttp {
058            public static com.liferay.portlet.asset.model.AssetVocabulary addVocabulary(
059                    HttpPrincipal httpPrincipal,
060                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
061                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
062                    java.lang.String settings,
063                    com.liferay.portal.service.ServiceContext serviceContext)
064                    throws com.liferay.portal.kernel.exception.PortalException {
065                    try {
066                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
067                                            "addVocabulary", _addVocabularyParameterTypes0);
068    
069                            MethodHandler methodHandler = new MethodHandler(methodKey,
070                                            titleMap, descriptionMap, settings, serviceContext);
071    
072                            Object returnObj = null;
073    
074                            try {
075                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
076                            }
077                            catch (Exception e) {
078                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
079                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
080                                    }
081    
082                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
083                            }
084    
085                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
086                    }
087                    catch (com.liferay.portal.kernel.exception.SystemException se) {
088                            _log.error(se, se);
089    
090                            throw se;
091                    }
092            }
093    
094            public static com.liferay.portlet.asset.model.AssetVocabulary addVocabulary(
095                    HttpPrincipal httpPrincipal, java.lang.String title,
096                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
097                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
098                    java.lang.String settings,
099                    com.liferay.portal.service.ServiceContext serviceContext)
100                    throws com.liferay.portal.kernel.exception.PortalException {
101                    try {
102                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
103                                            "addVocabulary", _addVocabularyParameterTypes1);
104    
105                            MethodHandler methodHandler = new MethodHandler(methodKey, title,
106                                            titleMap, descriptionMap, settings, serviceContext);
107    
108                            Object returnObj = null;
109    
110                            try {
111                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
112                            }
113                            catch (Exception e) {
114                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
115                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
116                                    }
117    
118                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
119                            }
120    
121                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
122                    }
123                    catch (com.liferay.portal.kernel.exception.SystemException se) {
124                            _log.error(se, se);
125    
126                            throw se;
127                    }
128            }
129    
130            public static com.liferay.portlet.asset.model.AssetVocabulary addVocabulary(
131                    HttpPrincipal httpPrincipal, java.lang.String title,
132                    com.liferay.portal.service.ServiceContext serviceContext)
133                    throws com.liferay.portal.kernel.exception.PortalException {
134                    try {
135                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
136                                            "addVocabulary", _addVocabularyParameterTypes2);
137    
138                            MethodHandler methodHandler = new MethodHandler(methodKey, title,
139                                            serviceContext);
140    
141                            Object returnObj = null;
142    
143                            try {
144                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
145                            }
146                            catch (Exception e) {
147                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
148                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
149                                    }
150    
151                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
152                            }
153    
154                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
155                    }
156                    catch (com.liferay.portal.kernel.exception.SystemException se) {
157                            _log.error(se, se);
158    
159                            throw se;
160                    }
161            }
162    
163            public static void deleteVocabularies(HttpPrincipal httpPrincipal,
164                    long[] vocabularyIds)
165                    throws com.liferay.portal.kernel.exception.PortalException {
166                    try {
167                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
168                                            "deleteVocabularies", _deleteVocabulariesParameterTypes3);
169    
170                            MethodHandler methodHandler = new MethodHandler(methodKey,
171                                            vocabularyIds);
172    
173                            try {
174                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
175                            }
176                            catch (Exception e) {
177                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
178                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
179                                    }
180    
181                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
182                            }
183                    }
184                    catch (com.liferay.portal.kernel.exception.SystemException se) {
185                            _log.error(se, se);
186    
187                            throw se;
188                    }
189            }
190    
191            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> deleteVocabularies(
192                    HttpPrincipal httpPrincipal, long[] vocabularyIds,
193                    com.liferay.portal.service.ServiceContext serviceContext)
194                    throws com.liferay.portal.kernel.exception.PortalException {
195                    try {
196                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
197                                            "deleteVocabularies", _deleteVocabulariesParameterTypes4);
198    
199                            MethodHandler methodHandler = new MethodHandler(methodKey,
200                                            vocabularyIds, serviceContext);
201    
202                            Object returnObj = null;
203    
204                            try {
205                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
206                            }
207                            catch (Exception e) {
208                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
209                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
210                                    }
211    
212                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
213                            }
214    
215                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
216                    }
217                    catch (com.liferay.portal.kernel.exception.SystemException se) {
218                            _log.error(se, se);
219    
220                            throw se;
221                    }
222            }
223    
224            public static void deleteVocabulary(HttpPrincipal httpPrincipal,
225                    long vocabularyId)
226                    throws com.liferay.portal.kernel.exception.PortalException {
227                    try {
228                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
229                                            "deleteVocabulary", _deleteVocabularyParameterTypes5);
230    
231                            MethodHandler methodHandler = new MethodHandler(methodKey,
232                                            vocabularyId);
233    
234                            try {
235                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
236                            }
237                            catch (Exception e) {
238                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
239                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
240                                    }
241    
242                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
243                            }
244                    }
245                    catch (com.liferay.portal.kernel.exception.SystemException se) {
246                            _log.error(se, se);
247    
248                            throw se;
249                    }
250            }
251    
252            public static com.liferay.portlet.asset.model.AssetVocabulary fetchVocabulary(
253                    HttpPrincipal httpPrincipal, long vocabularyId)
254                    throws com.liferay.portal.kernel.exception.PortalException {
255                    try {
256                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
257                                            "fetchVocabulary", _fetchVocabularyParameterTypes6);
258    
259                            MethodHandler methodHandler = new MethodHandler(methodKey,
260                                            vocabularyId);
261    
262                            Object returnObj = null;
263    
264                            try {
265                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
266                            }
267                            catch (Exception e) {
268                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
269                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
270                                    }
271    
272                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
273                            }
274    
275                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
276                    }
277                    catch (com.liferay.portal.kernel.exception.SystemException se) {
278                            _log.error(se, se);
279    
280                            throw se;
281                    }
282            }
283    
284            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getCompanyVocabularies(
285                    HttpPrincipal httpPrincipal, long companyId)
286                    throws com.liferay.portal.kernel.exception.PortalException {
287                    try {
288                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
289                                            "getCompanyVocabularies",
290                                            _getCompanyVocabulariesParameterTypes7);
291    
292                            MethodHandler methodHandler = new MethodHandler(methodKey, companyId);
293    
294                            Object returnObj = null;
295    
296                            try {
297                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
298                            }
299                            catch (Exception e) {
300                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
301                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
302                                    }
303    
304                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
305                            }
306    
307                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
308                    }
309                    catch (com.liferay.portal.kernel.exception.SystemException se) {
310                            _log.error(se, se);
311    
312                            throw se;
313                    }
314            }
315    
316            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupsVocabularies(
317                    HttpPrincipal httpPrincipal, long[] groupIds) {
318                    try {
319                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
320                                            "getGroupsVocabularies",
321                                            _getGroupsVocabulariesParameterTypes8);
322    
323                            MethodHandler methodHandler = new MethodHandler(methodKey, groupIds);
324    
325                            Object returnObj = null;
326    
327                            try {
328                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
329                            }
330                            catch (Exception e) {
331                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
332                            }
333    
334                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
335                    }
336                    catch (com.liferay.portal.kernel.exception.SystemException se) {
337                            _log.error(se, se);
338    
339                            throw se;
340                    }
341            }
342    
343            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupsVocabularies(
344                    HttpPrincipal httpPrincipal, long[] groupIds, java.lang.String className) {
345                    try {
346                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
347                                            "getGroupsVocabularies",
348                                            _getGroupsVocabulariesParameterTypes9);
349    
350                            MethodHandler methodHandler = new MethodHandler(methodKey,
351                                            groupIds, className);
352    
353                            Object returnObj = null;
354    
355                            try {
356                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
357                            }
358                            catch (Exception e) {
359                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
360                            }
361    
362                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
363                    }
364                    catch (com.liferay.portal.kernel.exception.SystemException se) {
365                            _log.error(se, se);
366    
367                            throw se;
368                    }
369            }
370    
371            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupsVocabularies(
372                    HttpPrincipal httpPrincipal, long[] groupIds,
373                    java.lang.String className, long classTypePK) {
374                    try {
375                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
376                                            "getGroupsVocabularies",
377                                            _getGroupsVocabulariesParameterTypes10);
378    
379                            MethodHandler methodHandler = new MethodHandler(methodKey,
380                                            groupIds, className, classTypePK);
381    
382                            Object returnObj = null;
383    
384                            try {
385                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
386                            }
387                            catch (Exception e) {
388                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
389                            }
390    
391                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
392                    }
393                    catch (com.liferay.portal.kernel.exception.SystemException se) {
394                            _log.error(se, se);
395    
396                            throw se;
397                    }
398            }
399    
400            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupVocabularies(
401                    HttpPrincipal httpPrincipal, long groupId)
402                    throws com.liferay.portal.kernel.exception.PortalException {
403                    try {
404                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
405                                            "getGroupVocabularies",
406                                            _getGroupVocabulariesParameterTypes11);
407    
408                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId);
409    
410                            Object returnObj = null;
411    
412                            try {
413                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
414                            }
415                            catch (Exception e) {
416                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
417                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
418                                    }
419    
420                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
421                            }
422    
423                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
424                    }
425                    catch (com.liferay.portal.kernel.exception.SystemException se) {
426                            _log.error(se, se);
427    
428                            throw se;
429                    }
430            }
431    
432            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupVocabularies(
433                    HttpPrincipal httpPrincipal, long groupId,
434                    boolean createDefaultVocabulary)
435                    throws com.liferay.portal.kernel.exception.PortalException {
436                    try {
437                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
438                                            "getGroupVocabularies",
439                                            _getGroupVocabulariesParameterTypes12);
440    
441                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
442                                            createDefaultVocabulary);
443    
444                            Object returnObj = null;
445    
446                            try {
447                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
448                            }
449                            catch (Exception e) {
450                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
451                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
452                                    }
453    
454                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
455                            }
456    
457                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
458                    }
459                    catch (com.liferay.portal.kernel.exception.SystemException se) {
460                            _log.error(se, se);
461    
462                            throw se;
463                    }
464            }
465    
466            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupVocabularies(
467                    HttpPrincipal httpPrincipal, long groupId,
468                    boolean createDefaultVocabulary, int start, int end,
469                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetVocabulary> obc)
470                    throws com.liferay.portal.kernel.exception.PortalException {
471                    try {
472                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
473                                            "getGroupVocabularies",
474                                            _getGroupVocabulariesParameterTypes13);
475    
476                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
477                                            createDefaultVocabulary, start, end, obc);
478    
479                            Object returnObj = null;
480    
481                            try {
482                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
483                            }
484                            catch (Exception e) {
485                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
486                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
487                                    }
488    
489                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
490                            }
491    
492                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
493                    }
494                    catch (com.liferay.portal.kernel.exception.SystemException se) {
495                            _log.error(se, se);
496    
497                            throw se;
498                    }
499            }
500    
501            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupVocabularies(
502                    HttpPrincipal httpPrincipal, long groupId, int start, int end,
503                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetVocabulary> obc) {
504                    try {
505                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
506                                            "getGroupVocabularies",
507                                            _getGroupVocabulariesParameterTypes14);
508    
509                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
510                                            start, end, obc);
511    
512                            Object returnObj = null;
513    
514                            try {
515                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
516                            }
517                            catch (Exception e) {
518                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
519                            }
520    
521                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
522                    }
523                    catch (com.liferay.portal.kernel.exception.SystemException se) {
524                            _log.error(se, se);
525    
526                            throw se;
527                    }
528            }
529    
530            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupVocabularies(
531                    HttpPrincipal httpPrincipal, long groupId, java.lang.String name,
532                    int start, int end,
533                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetVocabulary> obc) {
534                    try {
535                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
536                                            "getGroupVocabularies",
537                                            _getGroupVocabulariesParameterTypes15);
538    
539                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
540                                            name, start, end, obc);
541    
542                            Object returnObj = null;
543    
544                            try {
545                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
546                            }
547                            catch (Exception e) {
548                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
549                            }
550    
551                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
552                    }
553                    catch (com.liferay.portal.kernel.exception.SystemException se) {
554                            _log.error(se, se);
555    
556                            throw se;
557                    }
558            }
559    
560            public static java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getGroupVocabularies(
561                    HttpPrincipal httpPrincipal, long[] groupIds) {
562                    try {
563                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
564                                            "getGroupVocabularies",
565                                            _getGroupVocabulariesParameterTypes16);
566    
567                            MethodHandler methodHandler = new MethodHandler(methodKey, groupIds);
568    
569                            Object returnObj = null;
570    
571                            try {
572                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
573                            }
574                            catch (Exception e) {
575                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
576                            }
577    
578                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
579                    }
580                    catch (com.liferay.portal.kernel.exception.SystemException se) {
581                            _log.error(se, se);
582    
583                            throw se;
584                    }
585            }
586    
587            public static int getGroupVocabulariesCount(HttpPrincipal httpPrincipal,
588                    long groupId) {
589                    try {
590                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
591                                            "getGroupVocabulariesCount",
592                                            _getGroupVocabulariesCountParameterTypes17);
593    
594                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId);
595    
596                            Object returnObj = null;
597    
598                            try {
599                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
600                            }
601                            catch (Exception e) {
602                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
603                            }
604    
605                            return ((Integer)returnObj).intValue();
606                    }
607                    catch (com.liferay.portal.kernel.exception.SystemException se) {
608                            _log.error(se, se);
609    
610                            throw se;
611                    }
612            }
613    
614            public static int getGroupVocabulariesCount(HttpPrincipal httpPrincipal,
615                    long groupId, java.lang.String name) {
616                    try {
617                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
618                                            "getGroupVocabulariesCount",
619                                            _getGroupVocabulariesCountParameterTypes18);
620    
621                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
622                                            name);
623    
624                            Object returnObj = null;
625    
626                            try {
627                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
628                            }
629                            catch (Exception e) {
630                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
631                            }
632    
633                            return ((Integer)returnObj).intValue();
634                    }
635                    catch (com.liferay.portal.kernel.exception.SystemException se) {
636                            _log.error(se, se);
637    
638                            throw se;
639                    }
640            }
641    
642            public static int getGroupVocabulariesCount(HttpPrincipal httpPrincipal,
643                    long[] groupIds) {
644                    try {
645                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
646                                            "getGroupVocabulariesCount",
647                                            _getGroupVocabulariesCountParameterTypes19);
648    
649                            MethodHandler methodHandler = new MethodHandler(methodKey, groupIds);
650    
651                            Object returnObj = null;
652    
653                            try {
654                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
655                            }
656                            catch (Exception e) {
657                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
658                            }
659    
660                            return ((Integer)returnObj).intValue();
661                    }
662                    catch (com.liferay.portal.kernel.exception.SystemException se) {
663                            _log.error(se, se);
664    
665                            throw se;
666                    }
667            }
668    
669            public static com.liferay.portlet.asset.model.AssetVocabularyDisplay getGroupVocabulariesDisplay(
670                    HttpPrincipal httpPrincipal, long groupId, java.lang.String name,
671                    int start, int end, boolean addDefaultVocabulary,
672                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetVocabulary> obc)
673                    throws com.liferay.portal.kernel.exception.PortalException {
674                    try {
675                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
676                                            "getGroupVocabulariesDisplay",
677                                            _getGroupVocabulariesDisplayParameterTypes20);
678    
679                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
680                                            name, start, end, addDefaultVocabulary, obc);
681    
682                            Object returnObj = null;
683    
684                            try {
685                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
686                            }
687                            catch (Exception e) {
688                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
689                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
690                                    }
691    
692                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
693                            }
694    
695                            return (com.liferay.portlet.asset.model.AssetVocabularyDisplay)returnObj;
696                    }
697                    catch (com.liferay.portal.kernel.exception.SystemException se) {
698                            _log.error(se, se);
699    
700                            throw se;
701                    }
702            }
703    
704            public static com.liferay.portlet.asset.model.AssetVocabularyDisplay getGroupVocabulariesDisplay(
705                    HttpPrincipal httpPrincipal, long groupId, java.lang.String name,
706                    int start, int end,
707                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetVocabulary> obc)
708                    throws com.liferay.portal.kernel.exception.PortalException {
709                    try {
710                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
711                                            "getGroupVocabulariesDisplay",
712                                            _getGroupVocabulariesDisplayParameterTypes21);
713    
714                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
715                                            name, start, end, obc);
716    
717                            Object returnObj = null;
718    
719                            try {
720                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
721                            }
722                            catch (Exception e) {
723                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
724                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
725                                    }
726    
727                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
728                            }
729    
730                            return (com.liferay.portlet.asset.model.AssetVocabularyDisplay)returnObj;
731                    }
732                    catch (com.liferay.portal.kernel.exception.SystemException se) {
733                            _log.error(se, se);
734    
735                            throw se;
736                    }
737            }
738    
739            public static com.liferay.portal.kernel.json.JSONObject getJSONGroupVocabularies(
740                    HttpPrincipal httpPrincipal, long groupId, java.lang.String name,
741                    int start, int end,
742                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetVocabulary> obc)
743                    throws com.liferay.portal.kernel.exception.PortalException {
744                    try {
745                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
746                                            "getJSONGroupVocabularies",
747                                            _getJSONGroupVocabulariesParameterTypes22);
748    
749                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
750                                            name, start, end, obc);
751    
752                            Object returnObj = null;
753    
754                            try {
755                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
756                            }
757                            catch (Exception e) {
758                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
759                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
760                                    }
761    
762                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
763                            }
764    
765                            return (com.liferay.portal.kernel.json.JSONObject)returnObj;
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 java.util.List<com.liferay.portlet.asset.model.AssetVocabulary> getVocabularies(
775                    HttpPrincipal httpPrincipal, long[] vocabularyIds)
776                    throws com.liferay.portal.kernel.exception.PortalException {
777                    try {
778                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
779                                            "getVocabularies", _getVocabulariesParameterTypes23);
780    
781                            MethodHandler methodHandler = new MethodHandler(methodKey,
782                                            vocabularyIds);
783    
784                            Object returnObj = null;
785    
786                            try {
787                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
788                            }
789                            catch (Exception e) {
790                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
791                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
792                                    }
793    
794                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
795                            }
796    
797                            return (java.util.List<com.liferay.portlet.asset.model.AssetVocabulary>)returnObj;
798                    }
799                    catch (com.liferay.portal.kernel.exception.SystemException se) {
800                            _log.error(se, se);
801    
802                            throw se;
803                    }
804            }
805    
806            public static com.liferay.portlet.asset.model.AssetVocabulary getVocabulary(
807                    HttpPrincipal httpPrincipal, long vocabularyId)
808                    throws com.liferay.portal.kernel.exception.PortalException {
809                    try {
810                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
811                                            "getVocabulary", _getVocabularyParameterTypes24);
812    
813                            MethodHandler methodHandler = new MethodHandler(methodKey,
814                                            vocabularyId);
815    
816                            Object returnObj = null;
817    
818                            try {
819                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
820                            }
821                            catch (Exception e) {
822                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
823                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
824                                    }
825    
826                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
827                            }
828    
829                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
830                    }
831                    catch (com.liferay.portal.kernel.exception.SystemException se) {
832                            _log.error(se, se);
833    
834                            throw se;
835                    }
836            }
837    
838            public static com.liferay.portlet.asset.model.AssetVocabularyDisplay searchVocabulariesDisplay(
839                    HttpPrincipal httpPrincipal, long groupId, java.lang.String title,
840                    int start, int end, boolean addDefaultVocabulary)
841                    throws com.liferay.portal.kernel.exception.PortalException {
842                    try {
843                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
844                                            "searchVocabulariesDisplay",
845                                            _searchVocabulariesDisplayParameterTypes25);
846    
847                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
848                                            title, start, end, addDefaultVocabulary);
849    
850                            Object returnObj = null;
851    
852                            try {
853                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
854                            }
855                            catch (Exception e) {
856                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
857                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
858                                    }
859    
860                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
861                            }
862    
863                            return (com.liferay.portlet.asset.model.AssetVocabularyDisplay)returnObj;
864                    }
865                    catch (com.liferay.portal.kernel.exception.SystemException se) {
866                            _log.error(se, se);
867    
868                            throw se;
869                    }
870            }
871    
872            public static com.liferay.portlet.asset.model.AssetVocabulary updateVocabulary(
873                    HttpPrincipal httpPrincipal, long vocabularyId,
874                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
875                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
876                    java.lang.String settings,
877                    com.liferay.portal.service.ServiceContext serviceContext)
878                    throws com.liferay.portal.kernel.exception.PortalException {
879                    try {
880                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
881                                            "updateVocabulary", _updateVocabularyParameterTypes26);
882    
883                            MethodHandler methodHandler = new MethodHandler(methodKey,
884                                            vocabularyId, titleMap, descriptionMap, settings,
885                                            serviceContext);
886    
887                            Object returnObj = null;
888    
889                            try {
890                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
891                            }
892                            catch (Exception e) {
893                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
894                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
895                                    }
896    
897                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
898                            }
899    
900                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
901                    }
902                    catch (com.liferay.portal.kernel.exception.SystemException se) {
903                            _log.error(se, se);
904    
905                            throw se;
906                    }
907            }
908    
909            public static com.liferay.portlet.asset.model.AssetVocabulary updateVocabulary(
910                    HttpPrincipal httpPrincipal, long vocabularyId, java.lang.String title,
911                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
912                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
913                    java.lang.String settings,
914                    com.liferay.portal.service.ServiceContext serviceContext)
915                    throws com.liferay.portal.kernel.exception.PortalException {
916                    try {
917                            MethodKey methodKey = new MethodKey(AssetVocabularyServiceUtil.class,
918                                            "updateVocabulary", _updateVocabularyParameterTypes27);
919    
920                            MethodHandler methodHandler = new MethodHandler(methodKey,
921                                            vocabularyId, title, titleMap, descriptionMap, settings,
922                                            serviceContext);
923    
924                            Object returnObj = null;
925    
926                            try {
927                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
928                            }
929                            catch (Exception e) {
930                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
931                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
932                                    }
933    
934                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
935                            }
936    
937                            return (com.liferay.portlet.asset.model.AssetVocabulary)returnObj;
938                    }
939                    catch (com.liferay.portal.kernel.exception.SystemException se) {
940                            _log.error(se, se);
941    
942                            throw se;
943                    }
944            }
945    
946            private static Log _log = LogFactoryUtil.getLog(AssetVocabularyServiceHttp.class);
947            private static final Class<?>[] _addVocabularyParameterTypes0 = new Class[] {
948                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
949                            com.liferay.portal.service.ServiceContext.class
950                    };
951            private static final Class<?>[] _addVocabularyParameterTypes1 = new Class[] {
952                            java.lang.String.class, java.util.Map.class, java.util.Map.class,
953                            java.lang.String.class,
954                            com.liferay.portal.service.ServiceContext.class
955                    };
956            private static final Class<?>[] _addVocabularyParameterTypes2 = new Class[] {
957                            java.lang.String.class,
958                            com.liferay.portal.service.ServiceContext.class
959                    };
960            private static final Class<?>[] _deleteVocabulariesParameterTypes3 = new Class[] {
961                            long[].class
962                    };
963            private static final Class<?>[] _deleteVocabulariesParameterTypes4 = new Class[] {
964                            long[].class, com.liferay.portal.service.ServiceContext.class
965                    };
966            private static final Class<?>[] _deleteVocabularyParameterTypes5 = new Class[] {
967                            long.class
968                    };
969            private static final Class<?>[] _fetchVocabularyParameterTypes6 = new Class[] {
970                            long.class
971                    };
972            private static final Class<?>[] _getCompanyVocabulariesParameterTypes7 = new Class[] {
973                            long.class
974                    };
975            private static final Class<?>[] _getGroupsVocabulariesParameterTypes8 = new Class[] {
976                            long[].class
977                    };
978            private static final Class<?>[] _getGroupsVocabulariesParameterTypes9 = new Class[] {
979                            long[].class, java.lang.String.class
980                    };
981            private static final Class<?>[] _getGroupsVocabulariesParameterTypes10 = new Class[] {
982                            long[].class, java.lang.String.class, long.class
983                    };
984            private static final Class<?>[] _getGroupVocabulariesParameterTypes11 = new Class[] {
985                            long.class
986                    };
987            private static final Class<?>[] _getGroupVocabulariesParameterTypes12 = new Class[] {
988                            long.class, boolean.class
989                    };
990            private static final Class<?>[] _getGroupVocabulariesParameterTypes13 = new Class[] {
991                            long.class, boolean.class, int.class, int.class,
992                            com.liferay.portal.kernel.util.OrderByComparator.class
993                    };
994            private static final Class<?>[] _getGroupVocabulariesParameterTypes14 = new Class[] {
995                            long.class, int.class, int.class,
996                            com.liferay.portal.kernel.util.OrderByComparator.class
997                    };
998            private static final Class<?>[] _getGroupVocabulariesParameterTypes15 = new Class[] {
999                            long.class, java.lang.String.class, int.class, int.class,
1000                            com.liferay.portal.kernel.util.OrderByComparator.class
1001                    };
1002            private static final Class<?>[] _getGroupVocabulariesParameterTypes16 = new Class[] {
1003                            long[].class
1004                    };
1005            private static final Class<?>[] _getGroupVocabulariesCountParameterTypes17 = new Class[] {
1006                            long.class
1007                    };
1008            private static final Class<?>[] _getGroupVocabulariesCountParameterTypes18 = new Class[] {
1009                            long.class, java.lang.String.class
1010                    };
1011            private static final Class<?>[] _getGroupVocabulariesCountParameterTypes19 = new Class[] {
1012                            long[].class
1013                    };
1014            private static final Class<?>[] _getGroupVocabulariesDisplayParameterTypes20 =
1015                    new Class[] {
1016                            long.class, java.lang.String.class, int.class, int.class,
1017                            boolean.class,
1018                            com.liferay.portal.kernel.util.OrderByComparator.class
1019                    };
1020            private static final Class<?>[] _getGroupVocabulariesDisplayParameterTypes21 =
1021                    new Class[] {
1022                            long.class, java.lang.String.class, int.class, int.class,
1023                            com.liferay.portal.kernel.util.OrderByComparator.class
1024                    };
1025            private static final Class<?>[] _getJSONGroupVocabulariesParameterTypes22 = new Class[] {
1026                            long.class, java.lang.String.class, int.class, int.class,
1027                            com.liferay.portal.kernel.util.OrderByComparator.class
1028                    };
1029            private static final Class<?>[] _getVocabulariesParameterTypes23 = new Class[] {
1030                            long[].class
1031                    };
1032            private static final Class<?>[] _getVocabularyParameterTypes24 = new Class[] {
1033                            long.class
1034                    };
1035            private static final Class<?>[] _searchVocabulariesDisplayParameterTypes25 = new Class[] {
1036                            long.class, java.lang.String.class, int.class, int.class,
1037                            boolean.class
1038                    };
1039            private static final Class<?>[] _updateVocabularyParameterTypes26 = new Class[] {
1040                            long.class, java.util.Map.class, java.util.Map.class,
1041                            java.lang.String.class,
1042                            com.liferay.portal.service.ServiceContext.class
1043                    };
1044            private static final Class<?>[] _updateVocabularyParameterTypes27 = new Class[] {
1045                            long.class, java.lang.String.class, java.util.Map.class,
1046                            java.util.Map.class, java.lang.String.class,
1047                            com.liferay.portal.service.ServiceContext.class
1048                    };
1049    }