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.portal.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.LayoutServiceUtil;
025    
026    /**
027     * Provides the HTTP utility for the
028     * {@link com.liferay.portal.service.LayoutServiceUtil} service utility. The
029     * static methods of this class calls the same methods of the service utility.
030     * However, the signatures are different because it requires an additional
031     * {@link com.liferay.portal.security.auth.HttpPrincipal} parameter.
032     *
033     * <p>
034     * The benefits of using the HTTP utility is that it is fast and allows for
035     * tunneling without the cost of serializing to text. The drawback is that it
036     * only works with Java.
037     * </p>
038     *
039     * <p>
040     * Set the property <b>tunnel.servlet.hosts.allowed</b> in portal.properties to
041     * configure security.
042     * </p>
043     *
044     * <p>
045     * The HTTP utility is only generated for remote services.
046     * </p>
047     *
048     * @author Brian Wing Shun Chan
049     * @see LayoutServiceSoap
050     * @see com.liferay.portal.security.auth.HttpPrincipal
051     * @see com.liferay.portal.service.LayoutServiceUtil
052     * @generated
053     */
054    @ProviderType
055    public class LayoutServiceHttp {
056            public static com.liferay.portal.model.Layout addLayout(
057                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
058                    long parentLayoutId,
059                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
060                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
061                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
062                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
063                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
064                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
065                    com.liferay.portal.service.ServiceContext serviceContext)
066                    throws com.liferay.portal.kernel.exception.PortalException {
067                    try {
068                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
069                                            "addLayout", _addLayoutParameterTypes0);
070    
071                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
072                                            privateLayout, parentLayoutId, localeNamesMap,
073                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
074                                            type, hidden, friendlyURL, serviceContext);
075    
076                            Object returnObj = null;
077    
078                            try {
079                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
080                            }
081                            catch (Exception e) {
082                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
083                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
084                                    }
085    
086                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
087                            }
088    
089                            return (com.liferay.portal.model.Layout)returnObj;
090                    }
091                    catch (com.liferay.portal.kernel.exception.SystemException se) {
092                            _log.error(se, se);
093    
094                            throw se;
095                    }
096            }
097    
098            public static com.liferay.portal.model.Layout addLayout(
099                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
100                    long parentLayoutId,
101                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
102                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
103                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
104                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
105                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
106                    java.lang.String type, java.lang.String typeSettings, boolean hidden,
107                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
108                    com.liferay.portal.service.ServiceContext serviceContext)
109                    throws com.liferay.portal.kernel.exception.PortalException {
110                    try {
111                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
112                                            "addLayout", _addLayoutParameterTypes1);
113    
114                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
115                                            privateLayout, parentLayoutId, localeNamesMap,
116                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
117                                            type, typeSettings, hidden, friendlyURLMap, serviceContext);
118    
119                            Object returnObj = null;
120    
121                            try {
122                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
123                            }
124                            catch (Exception e) {
125                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
126                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
127                                    }
128    
129                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
130                            }
131    
132                            return (com.liferay.portal.model.Layout)returnObj;
133                    }
134                    catch (com.liferay.portal.kernel.exception.SystemException se) {
135                            _log.error(se, se);
136    
137                            throw se;
138                    }
139            }
140    
141            public static com.liferay.portal.model.Layout addLayout(
142                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
143                    long parentLayoutId, java.lang.String name, java.lang.String title,
144                    java.lang.String description, java.lang.String type, boolean hidden,
145                    java.lang.String friendlyURL,
146                    com.liferay.portal.service.ServiceContext serviceContext)
147                    throws com.liferay.portal.kernel.exception.PortalException {
148                    try {
149                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
150                                            "addLayout", _addLayoutParameterTypes2);
151    
152                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
153                                            privateLayout, parentLayoutId, name, title, description,
154                                            type, hidden, friendlyURL, serviceContext);
155    
156                            Object returnObj = null;
157    
158                            try {
159                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
160                            }
161                            catch (Exception e) {
162                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
163                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
164                                    }
165    
166                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
167                            }
168    
169                            return (com.liferay.portal.model.Layout)returnObj;
170                    }
171                    catch (com.liferay.portal.kernel.exception.SystemException se) {
172                            _log.error(se, se);
173    
174                            throw se;
175                    }
176            }
177    
178            public static com.liferay.portal.kernel.repository.model.FileEntry addTempFileEntry(
179                    HttpPrincipal httpPrincipal, long groupId, java.lang.String folderName,
180                    java.lang.String fileName, java.io.InputStream inputStream,
181                    java.lang.String mimeType)
182                    throws com.liferay.portal.kernel.exception.PortalException {
183                    try {
184                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
185                                            "addTempFileEntry", _addTempFileEntryParameterTypes3);
186    
187                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
188                                            folderName, fileName, inputStream, mimeType);
189    
190                            Object returnObj = null;
191    
192                            try {
193                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
194                            }
195                            catch (Exception e) {
196                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
197                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
198                                    }
199    
200                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
201                            }
202    
203                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
204                    }
205                    catch (com.liferay.portal.kernel.exception.SystemException se) {
206                            _log.error(se, se);
207    
208                            throw se;
209                    }
210            }
211    
212            public static void deleteLayout(HttpPrincipal httpPrincipal, long groupId,
213                    boolean privateLayout, long layoutId,
214                    com.liferay.portal.service.ServiceContext serviceContext)
215                    throws com.liferay.portal.kernel.exception.PortalException {
216                    try {
217                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
218                                            "deleteLayout", _deleteLayoutParameterTypes4);
219    
220                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
221                                            privateLayout, layoutId, serviceContext);
222    
223                            try {
224                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
225                            }
226                            catch (Exception e) {
227                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
228                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
229                                    }
230    
231                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
232                            }
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 void deleteLayout(HttpPrincipal httpPrincipal, long plid,
242                    com.liferay.portal.service.ServiceContext serviceContext)
243                    throws com.liferay.portal.kernel.exception.PortalException {
244                    try {
245                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
246                                            "deleteLayout", _deleteLayoutParameterTypes5);
247    
248                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
249                                            serviceContext);
250    
251                            try {
252                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
253                            }
254                            catch (Exception e) {
255                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
256                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
257                                    }
258    
259                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
260                            }
261                    }
262                    catch (com.liferay.portal.kernel.exception.SystemException se) {
263                            _log.error(se, se);
264    
265                            throw se;
266                    }
267            }
268    
269            public static void deleteTempFileEntry(HttpPrincipal httpPrincipal,
270                    long groupId, java.lang.String folderName, java.lang.String fileName)
271                    throws com.liferay.portal.kernel.exception.PortalException {
272                    try {
273                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
274                                            "deleteTempFileEntry", _deleteTempFileEntryParameterTypes6);
275    
276                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
277                                            folderName, fileName);
278    
279                            try {
280                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
281                            }
282                            catch (Exception e) {
283                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
284                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
285                                    }
286    
287                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
288                            }
289                    }
290                    catch (com.liferay.portal.kernel.exception.SystemException se) {
291                            _log.error(se, se);
292    
293                            throw se;
294                    }
295            }
296    
297            public static byte[] exportLayouts(HttpPrincipal httpPrincipal,
298                    long groupId, boolean privateLayout, long[] layoutIds,
299                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
300                    java.util.Date startDate, java.util.Date endDate)
301                    throws com.liferay.portal.kernel.exception.PortalException {
302                    try {
303                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
304                                            "exportLayouts", _exportLayoutsParameterTypes7);
305    
306                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
307                                            privateLayout, layoutIds, parameterMap, startDate, endDate);
308    
309                            Object returnObj = null;
310    
311                            try {
312                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
313                            }
314                            catch (Exception e) {
315                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
316                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
317                                    }
318    
319                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
320                            }
321    
322                            return (byte[])returnObj;
323                    }
324                    catch (com.liferay.portal.kernel.exception.SystemException se) {
325                            _log.error(se, se);
326    
327                            throw se;
328                    }
329            }
330    
331            public static byte[] exportLayouts(HttpPrincipal httpPrincipal,
332                    long groupId, boolean privateLayout,
333                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
334                    java.util.Date startDate, java.util.Date endDate)
335                    throws com.liferay.portal.kernel.exception.PortalException {
336                    try {
337                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
338                                            "exportLayouts", _exportLayoutsParameterTypes8);
339    
340                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
341                                            privateLayout, parameterMap, startDate, endDate);
342    
343                            Object returnObj = null;
344    
345                            try {
346                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
347                            }
348                            catch (Exception e) {
349                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
350                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
351                                    }
352    
353                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
354                            }
355    
356                            return (byte[])returnObj;
357                    }
358                    catch (com.liferay.portal.kernel.exception.SystemException se) {
359                            _log.error(se, se);
360    
361                            throw se;
362                    }
363            }
364    
365            public static java.io.File exportLayoutsAsFile(
366                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
367                    long[] layoutIds,
368                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
369                    java.util.Date startDate, java.util.Date endDate)
370                    throws com.liferay.portal.kernel.exception.PortalException {
371                    try {
372                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
373                                            "exportLayoutsAsFile", _exportLayoutsAsFileParameterTypes9);
374    
375                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
376                                            privateLayout, layoutIds, parameterMap, startDate, endDate);
377    
378                            Object returnObj = null;
379    
380                            try {
381                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
382                            }
383                            catch (Exception e) {
384                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
385                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
386                                    }
387    
388                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
389                            }
390    
391                            return (java.io.File)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 long exportLayoutsAsFileInBackground(
401                    HttpPrincipal httpPrincipal,
402                    com.liferay.portal.model.ExportImportConfiguration exportImportConfiguration)
403                    throws com.liferay.portal.kernel.exception.PortalException {
404                    try {
405                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
406                                            "exportLayoutsAsFileInBackground",
407                                            _exportLayoutsAsFileInBackgroundParameterTypes10);
408    
409                            MethodHandler methodHandler = new MethodHandler(methodKey,
410                                            exportImportConfiguration);
411    
412                            Object returnObj = null;
413    
414                            try {
415                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
416                            }
417                            catch (Exception e) {
418                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
419                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
420                                    }
421    
422                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
423                            }
424    
425                            return ((Long)returnObj).longValue();
426                    }
427                    catch (com.liferay.portal.kernel.exception.SystemException se) {
428                            _log.error(se, se);
429    
430                            throw se;
431                    }
432            }
433    
434            public static long exportLayoutsAsFileInBackground(
435                    HttpPrincipal httpPrincipal, long exportImportConfigurationId)
436                    throws com.liferay.portal.kernel.exception.PortalException {
437                    try {
438                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
439                                            "exportLayoutsAsFileInBackground",
440                                            _exportLayoutsAsFileInBackgroundParameterTypes11);
441    
442                            MethodHandler methodHandler = new MethodHandler(methodKey,
443                                            exportImportConfigurationId);
444    
445                            Object returnObj = null;
446    
447                            try {
448                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
449                            }
450                            catch (Exception e) {
451                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
452                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
453                                    }
454    
455                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
456                            }
457    
458                            return ((Long)returnObj).longValue();
459                    }
460                    catch (com.liferay.portal.kernel.exception.SystemException se) {
461                            _log.error(se, se);
462    
463                            throw se;
464                    }
465            }
466    
467            public static long exportLayoutsAsFileInBackground(
468                    HttpPrincipal httpPrincipal, java.lang.String taskName, long groupId,
469                    boolean privateLayout, long[] layoutIds,
470                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
471                    java.util.Date startDate, java.util.Date endDate)
472                    throws com.liferay.portal.kernel.exception.PortalException {
473                    try {
474                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
475                                            "exportLayoutsAsFileInBackground",
476                                            _exportLayoutsAsFileInBackgroundParameterTypes12);
477    
478                            MethodHandler methodHandler = new MethodHandler(methodKey,
479                                            taskName, groupId, privateLayout, layoutIds, parameterMap,
480                                            startDate, endDate);
481    
482                            Object returnObj = null;
483    
484                            try {
485                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
486                            }
487                            catch (Exception e) {
488                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
489                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
490                                    }
491    
492                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
493                            }
494    
495                            return ((Long)returnObj).longValue();
496                    }
497                    catch (com.liferay.portal.kernel.exception.SystemException se) {
498                            _log.error(se, se);
499    
500                            throw se;
501                    }
502            }
503    
504            public static long exportLayoutsAsFileInBackground(
505                    HttpPrincipal httpPrincipal, java.lang.String taskName, long groupId,
506                    boolean privateLayout, long[] layoutIds,
507                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
508                    java.util.Date startDate, java.util.Date endDate,
509                    java.lang.String fileName)
510                    throws com.liferay.portal.kernel.exception.PortalException {
511                    try {
512                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
513                                            "exportLayoutsAsFileInBackground",
514                                            _exportLayoutsAsFileInBackgroundParameterTypes13);
515    
516                            MethodHandler methodHandler = new MethodHandler(methodKey,
517                                            taskName, groupId, privateLayout, layoutIds, parameterMap,
518                                            startDate, endDate, fileName);
519    
520                            Object returnObj = null;
521    
522                            try {
523                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
524                            }
525                            catch (Exception e) {
526                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
527                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
528                                    }
529    
530                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
531                            }
532    
533                            return ((Long)returnObj).longValue();
534                    }
535                    catch (com.liferay.portal.kernel.exception.SystemException se) {
536                            _log.error(se, se);
537    
538                            throw se;
539                    }
540            }
541    
542            public static byte[] exportPortletInfo(HttpPrincipal httpPrincipal,
543                    long plid, long groupId, java.lang.String portletId,
544                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
545                    java.util.Date startDate, java.util.Date endDate)
546                    throws com.liferay.portal.kernel.exception.PortalException {
547                    try {
548                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
549                                            "exportPortletInfo", _exportPortletInfoParameterTypes14);
550    
551                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
552                                            groupId, portletId, parameterMap, startDate, endDate);
553    
554                            Object returnObj = null;
555    
556                            try {
557                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
558                            }
559                            catch (Exception e) {
560                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
561                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
562                                    }
563    
564                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
565                            }
566    
567                            return (byte[])returnObj;
568                    }
569                    catch (com.liferay.portal.kernel.exception.SystemException se) {
570                            _log.error(se, se);
571    
572                            throw se;
573                    }
574            }
575    
576            public static byte[] exportPortletInfo(HttpPrincipal httpPrincipal,
577                    long companyId, java.lang.String portletId,
578                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
579                    java.util.Date startDate, java.util.Date endDate)
580                    throws com.liferay.portal.kernel.exception.PortalException {
581                    try {
582                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
583                                            "exportPortletInfo", _exportPortletInfoParameterTypes15);
584    
585                            MethodHandler methodHandler = new MethodHandler(methodKey,
586                                            companyId, portletId, parameterMap, startDate, endDate);
587    
588                            Object returnObj = null;
589    
590                            try {
591                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
592                            }
593                            catch (Exception e) {
594                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
595                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
596                                    }
597    
598                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
599                            }
600    
601                            return (byte[])returnObj;
602                    }
603                    catch (com.liferay.portal.kernel.exception.SystemException se) {
604                            _log.error(se, se);
605    
606                            throw se;
607                    }
608            }
609    
610            public static java.io.File exportPortletInfoAsFile(
611                    HttpPrincipal httpPrincipal, long plid, long groupId,
612                    java.lang.String portletId,
613                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
614                    java.util.Date startDate, java.util.Date endDate)
615                    throws com.liferay.portal.kernel.exception.PortalException {
616                    try {
617                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
618                                            "exportPortletInfoAsFile",
619                                            _exportPortletInfoAsFileParameterTypes16);
620    
621                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
622                                            groupId, portletId, parameterMap, startDate, endDate);
623    
624                            Object returnObj = null;
625    
626                            try {
627                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
628                            }
629                            catch (Exception e) {
630                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
631                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
632                                    }
633    
634                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
635                            }
636    
637                            return (java.io.File)returnObj;
638                    }
639                    catch (com.liferay.portal.kernel.exception.SystemException se) {
640                            _log.error(se, se);
641    
642                            throw se;
643                    }
644            }
645    
646            public static java.io.File exportPortletInfoAsFile(
647                    HttpPrincipal httpPrincipal, java.lang.String portletId,
648                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
649                    java.util.Date startDate, java.util.Date endDate)
650                    throws com.liferay.portal.kernel.exception.PortalException {
651                    try {
652                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
653                                            "exportPortletInfoAsFile",
654                                            _exportPortletInfoAsFileParameterTypes17);
655    
656                            MethodHandler methodHandler = new MethodHandler(methodKey,
657                                            portletId, parameterMap, startDate, endDate);
658    
659                            Object returnObj = null;
660    
661                            try {
662                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
663                            }
664                            catch (Exception e) {
665                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
666                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
667                                    }
668    
669                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
670                            }
671    
672                            return (java.io.File)returnObj;
673                    }
674                    catch (com.liferay.portal.kernel.exception.SystemException se) {
675                            _log.error(se, se);
676    
677                            throw se;
678                    }
679            }
680    
681            public static long exportPortletInfoAsFileInBackground(
682                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
683                    long groupId, java.lang.String portletId,
684                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
685                    java.util.Date startDate, java.util.Date endDate,
686                    java.lang.String fileName)
687                    throws com.liferay.portal.kernel.exception.PortalException {
688                    try {
689                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
690                                            "exportPortletInfoAsFileInBackground",
691                                            _exportPortletInfoAsFileInBackgroundParameterTypes18);
692    
693                            MethodHandler methodHandler = new MethodHandler(methodKey,
694                                            taskName, plid, groupId, portletId, parameterMap,
695                                            startDate, endDate, fileName);
696    
697                            Object returnObj = null;
698    
699                            try {
700                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
701                            }
702                            catch (Exception e) {
703                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
704                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
705                                    }
706    
707                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
708                            }
709    
710                            return ((Long)returnObj).longValue();
711                    }
712                    catch (com.liferay.portal.kernel.exception.SystemException se) {
713                            _log.error(se, se);
714    
715                            throw se;
716                    }
717            }
718    
719            public static long exportPortletInfoAsFileInBackground(
720                    HttpPrincipal httpPrincipal, java.lang.String taskName,
721                    java.lang.String portletId,
722                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
723                    java.util.Date startDate, java.util.Date endDate,
724                    java.lang.String fileName)
725                    throws com.liferay.portal.kernel.exception.PortalException {
726                    try {
727                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
728                                            "exportPortletInfoAsFileInBackground",
729                                            _exportPortletInfoAsFileInBackgroundParameterTypes19);
730    
731                            MethodHandler methodHandler = new MethodHandler(methodKey,
732                                            taskName, portletId, parameterMap, startDate, endDate,
733                                            fileName);
734    
735                            Object returnObj = null;
736    
737                            try {
738                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
739                            }
740                            catch (Exception e) {
741                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
742                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
743                                    }
744    
745                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
746                            }
747    
748                            return ((Long)returnObj).longValue();
749                    }
750                    catch (com.liferay.portal.kernel.exception.SystemException se) {
751                            _log.error(se, se);
752    
753                            throw se;
754                    }
755            }
756    
757            public static java.util.List<com.liferay.portal.model.Layout> getAncestorLayouts(
758                    HttpPrincipal httpPrincipal, long plid)
759                    throws com.liferay.portal.kernel.exception.PortalException {
760                    try {
761                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
762                                            "getAncestorLayouts", _getAncestorLayoutsParameterTypes20);
763    
764                            MethodHandler methodHandler = new MethodHandler(methodKey, plid);
765    
766                            Object returnObj = null;
767    
768                            try {
769                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
770                            }
771                            catch (Exception e) {
772                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
773                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
774                                    }
775    
776                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
777                            }
778    
779                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
780                    }
781                    catch (com.liferay.portal.kernel.exception.SystemException se) {
782                            _log.error(se, se);
783    
784                            throw se;
785                    }
786            }
787    
788            public static long getDefaultPlid(HttpPrincipal httpPrincipal,
789                    long groupId, long scopeGroupId, boolean privateLayout,
790                    java.lang.String portletId)
791                    throws com.liferay.portal.kernel.exception.PortalException {
792                    try {
793                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
794                                            "getDefaultPlid", _getDefaultPlidParameterTypes21);
795    
796                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
797                                            scopeGroupId, privateLayout, portletId);
798    
799                            Object returnObj = null;
800    
801                            try {
802                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
803                            }
804                            catch (Exception e) {
805                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
806                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
807                                    }
808    
809                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
810                            }
811    
812                            return ((Long)returnObj).longValue();
813                    }
814                    catch (com.liferay.portal.kernel.exception.SystemException se) {
815                            _log.error(se, se);
816    
817                            throw se;
818                    }
819            }
820    
821            public static long getDefaultPlid(HttpPrincipal httpPrincipal,
822                    long groupId, long scopeGroupId, java.lang.String portletId)
823                    throws com.liferay.portal.kernel.exception.PortalException {
824                    try {
825                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
826                                            "getDefaultPlid", _getDefaultPlidParameterTypes22);
827    
828                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
829                                            scopeGroupId, portletId);
830    
831                            Object returnObj = null;
832    
833                            try {
834                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
835                            }
836                            catch (Exception e) {
837                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
838                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
839                                    }
840    
841                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
842                            }
843    
844                            return ((Long)returnObj).longValue();
845                    }
846                    catch (com.liferay.portal.kernel.exception.SystemException se) {
847                            _log.error(se, se);
848    
849                            throw se;
850                    }
851            }
852    
853            public static com.liferay.portal.model.Layout getLayoutByUuidAndGroupId(
854                    HttpPrincipal httpPrincipal, java.lang.String uuid, long groupId,
855                    boolean privateLayout)
856                    throws com.liferay.portal.kernel.exception.PortalException {
857                    try {
858                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
859                                            "getLayoutByUuidAndGroupId",
860                                            _getLayoutByUuidAndGroupIdParameterTypes23);
861    
862                            MethodHandler methodHandler = new MethodHandler(methodKey, uuid,
863                                            groupId, privateLayout);
864    
865                            Object returnObj = null;
866    
867                            try {
868                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
869                            }
870                            catch (Exception e) {
871                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
872                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
873                                    }
874    
875                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
876                            }
877    
878                            return (com.liferay.portal.model.Layout)returnObj;
879                    }
880                    catch (com.liferay.portal.kernel.exception.SystemException se) {
881                            _log.error(se, se);
882    
883                            throw se;
884                    }
885            }
886    
887            public static java.lang.String getLayoutName(HttpPrincipal httpPrincipal,
888                    long groupId, boolean privateLayout, long layoutId,
889                    java.lang.String languageId)
890                    throws com.liferay.portal.kernel.exception.PortalException {
891                    try {
892                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
893                                            "getLayoutName", _getLayoutNameParameterTypes24);
894    
895                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
896                                            privateLayout, layoutId, languageId);
897    
898                            Object returnObj = null;
899    
900                            try {
901                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
902                            }
903                            catch (Exception e) {
904                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
905                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
906                                    }
907    
908                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
909                            }
910    
911                            return (java.lang.String)returnObj;
912                    }
913                    catch (com.liferay.portal.kernel.exception.SystemException se) {
914                            _log.error(se, se);
915    
916                            throw se;
917                    }
918            }
919    
920            public static com.liferay.portal.model.LayoutReference[] getLayoutReferences(
921                    HttpPrincipal httpPrincipal, long companyId,
922                    java.lang.String portletId, java.lang.String preferencesKey,
923                    java.lang.String preferencesValue) {
924                    try {
925                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
926                                            "getLayoutReferences", _getLayoutReferencesParameterTypes25);
927    
928                            MethodHandler methodHandler = new MethodHandler(methodKey,
929                                            companyId, portletId, preferencesKey, preferencesValue);
930    
931                            Object returnObj = null;
932    
933                            try {
934                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
935                            }
936                            catch (Exception e) {
937                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
938                            }
939    
940                            return (com.liferay.portal.model.LayoutReference[])returnObj;
941                    }
942                    catch (com.liferay.portal.kernel.exception.SystemException se) {
943                            _log.error(se, se);
944    
945                            throw se;
946                    }
947            }
948    
949            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
950                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout) {
951                    try {
952                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
953                                            "getLayouts", _getLayoutsParameterTypes26);
954    
955                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
956                                            privateLayout);
957    
958                            Object returnObj = null;
959    
960                            try {
961                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
962                            }
963                            catch (Exception e) {
964                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
965                            }
966    
967                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
968                    }
969                    catch (com.liferay.portal.kernel.exception.SystemException se) {
970                            _log.error(se, se);
971    
972                            throw se;
973                    }
974            }
975    
976            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
977                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
978                    long parentLayoutId) {
979                    try {
980                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
981                                            "getLayouts", _getLayoutsParameterTypes27);
982    
983                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
984                                            privateLayout, parentLayoutId);
985    
986                            Object returnObj = null;
987    
988                            try {
989                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
990                            }
991                            catch (Exception e) {
992                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
993                            }
994    
995                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
996                    }
997                    catch (com.liferay.portal.kernel.exception.SystemException se) {
998                            _log.error(se, se);
999    
1000                            throw se;
1001                    }
1002            }
1003    
1004            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
1005                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1006                    long parentLayoutId, boolean incomplete, int start, int end)
1007                    throws com.liferay.portal.kernel.exception.PortalException {
1008                    try {
1009                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1010                                            "getLayouts", _getLayoutsParameterTypes28);
1011    
1012                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1013                                            privateLayout, parentLayoutId, incomplete, start, end);
1014    
1015                            Object returnObj = null;
1016    
1017                            try {
1018                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1019                            }
1020                            catch (Exception e) {
1021                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1022                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1023                                    }
1024    
1025                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1026                            }
1027    
1028                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
1029                    }
1030                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1031                            _log.error(se, se);
1032    
1033                            throw se;
1034                    }
1035            }
1036    
1037            public static int getLayoutsCount(HttpPrincipal httpPrincipal,
1038                    long groupId, boolean privateLayout, long parentLayoutId) {
1039                    try {
1040                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1041                                            "getLayoutsCount", _getLayoutsCountParameterTypes29);
1042    
1043                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1044                                            privateLayout, parentLayoutId);
1045    
1046                            Object returnObj = null;
1047    
1048                            try {
1049                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1050                            }
1051                            catch (Exception e) {
1052                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1053                            }
1054    
1055                            return ((Integer)returnObj).intValue();
1056                    }
1057                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1058                            _log.error(se, se);
1059    
1060                            throw se;
1061                    }
1062            }
1063    
1064            public static java.lang.String[] getTempFileNames(
1065                    HttpPrincipal httpPrincipal, long groupId, java.lang.String folderName)
1066                    throws com.liferay.portal.kernel.exception.PortalException {
1067                    try {
1068                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1069                                            "getTempFileNames", _getTempFileNamesParameterTypes30);
1070    
1071                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1072                                            folderName);
1073    
1074                            Object returnObj = null;
1075    
1076                            try {
1077                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1078                            }
1079                            catch (Exception e) {
1080                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1081                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1082                                    }
1083    
1084                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1085                            }
1086    
1087                            return (java.lang.String[])returnObj;
1088                    }
1089                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1090                            _log.error(se, se);
1091    
1092                            throw se;
1093                    }
1094            }
1095    
1096            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1097                    boolean privateLayout,
1098                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1099                    byte[] bytes)
1100                    throws com.liferay.portal.kernel.exception.PortalException {
1101                    try {
1102                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1103                                            "importLayouts", _importLayoutsParameterTypes31);
1104    
1105                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1106                                            privateLayout, parameterMap, bytes);
1107    
1108                            try {
1109                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1110                            }
1111                            catch (Exception e) {
1112                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1113                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1114                                    }
1115    
1116                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1117                            }
1118                    }
1119                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1120                            _log.error(se, se);
1121    
1122                            throw se;
1123                    }
1124            }
1125    
1126            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1127                    boolean privateLayout,
1128                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1129                    java.io.File file)
1130                    throws com.liferay.portal.kernel.exception.PortalException {
1131                    try {
1132                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1133                                            "importLayouts", _importLayoutsParameterTypes32);
1134    
1135                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1136                                            privateLayout, parameterMap, file);
1137    
1138                            try {
1139                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1140                            }
1141                            catch (Exception e) {
1142                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1143                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1144                                    }
1145    
1146                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1147                            }
1148                    }
1149                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1150                            _log.error(se, se);
1151    
1152                            throw se;
1153                    }
1154            }
1155    
1156            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1157                    boolean privateLayout,
1158                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1159                    java.io.InputStream is)
1160                    throws com.liferay.portal.kernel.exception.PortalException {
1161                    try {
1162                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1163                                            "importLayouts", _importLayoutsParameterTypes33);
1164    
1165                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1166                                            privateLayout, parameterMap, is);
1167    
1168                            try {
1169                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1170                            }
1171                            catch (Exception e) {
1172                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1173                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1174                                    }
1175    
1176                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1177                            }
1178                    }
1179                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1180                            _log.error(se, se);
1181    
1182                            throw se;
1183                    }
1184            }
1185    
1186            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1187                    java.lang.String taskName, long groupId, boolean privateLayout,
1188                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1189                    java.io.File file)
1190                    throws com.liferay.portal.kernel.exception.PortalException {
1191                    try {
1192                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1193                                            "importLayoutsInBackground",
1194                                            _importLayoutsInBackgroundParameterTypes34);
1195    
1196                            MethodHandler methodHandler = new MethodHandler(methodKey,
1197                                            taskName, groupId, privateLayout, parameterMap, file);
1198    
1199                            Object returnObj = null;
1200    
1201                            try {
1202                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1203                            }
1204                            catch (Exception e) {
1205                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1206                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1207                                    }
1208    
1209                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1210                            }
1211    
1212                            return ((Long)returnObj).longValue();
1213                    }
1214                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1215                            _log.error(se, se);
1216    
1217                            throw se;
1218                    }
1219            }
1220    
1221            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1222                    java.lang.String taskName, long groupId, boolean privateLayout,
1223                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1224                    java.io.InputStream inputStream)
1225                    throws com.liferay.portal.kernel.exception.PortalException {
1226                    try {
1227                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1228                                            "importLayoutsInBackground",
1229                                            _importLayoutsInBackgroundParameterTypes35);
1230    
1231                            MethodHandler methodHandler = new MethodHandler(methodKey,
1232                                            taskName, groupId, privateLayout, parameterMap, inputStream);
1233    
1234                            Object returnObj = null;
1235    
1236                            try {
1237                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1238                            }
1239                            catch (Exception e) {
1240                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1241                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1242                                    }
1243    
1244                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1245                            }
1246    
1247                            return ((Long)returnObj).longValue();
1248                    }
1249                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1250                            _log.error(se, se);
1251    
1252                            throw se;
1253                    }
1254            }
1255    
1256            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1257                    long plid, long groupId, java.lang.String portletId,
1258                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1259                    java.io.File file)
1260                    throws com.liferay.portal.kernel.exception.PortalException {
1261                    try {
1262                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1263                                            "importPortletInfo", _importPortletInfoParameterTypes36);
1264    
1265                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1266                                            groupId, portletId, parameterMap, file);
1267    
1268                            try {
1269                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1270                            }
1271                            catch (Exception e) {
1272                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1273                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1274                                    }
1275    
1276                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1277                            }
1278                    }
1279                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1280                            _log.error(se, se);
1281    
1282                            throw se;
1283                    }
1284            }
1285    
1286            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1287                    long plid, long groupId, java.lang.String portletId,
1288                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1289                    java.io.InputStream is)
1290                    throws com.liferay.portal.kernel.exception.PortalException {
1291                    try {
1292                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1293                                            "importPortletInfo", _importPortletInfoParameterTypes37);
1294    
1295                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1296                                            groupId, portletId, parameterMap, is);
1297    
1298                            try {
1299                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1300                            }
1301                            catch (Exception e) {
1302                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1303                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1304                                    }
1305    
1306                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1307                            }
1308                    }
1309                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1310                            _log.error(se, se);
1311    
1312                            throw se;
1313                    }
1314            }
1315    
1316            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1317                    java.lang.String portletId,
1318                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1319                    java.io.File file)
1320                    throws com.liferay.portal.kernel.exception.PortalException {
1321                    try {
1322                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1323                                            "importPortletInfo", _importPortletInfoParameterTypes38);
1324    
1325                            MethodHandler methodHandler = new MethodHandler(methodKey,
1326                                            portletId, parameterMap, file);
1327    
1328                            try {
1329                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1330                            }
1331                            catch (Exception e) {
1332                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1333                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1334                                    }
1335    
1336                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1337                            }
1338                    }
1339                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1340                            _log.error(se, se);
1341    
1342                            throw se;
1343                    }
1344            }
1345    
1346            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1347                    java.lang.String portletId,
1348                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1349                    java.io.InputStream is)
1350                    throws com.liferay.portal.kernel.exception.PortalException {
1351                    try {
1352                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1353                                            "importPortletInfo", _importPortletInfoParameterTypes39);
1354    
1355                            MethodHandler methodHandler = new MethodHandler(methodKey,
1356                                            portletId, parameterMap, is);
1357    
1358                            try {
1359                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1360                            }
1361                            catch (Exception e) {
1362                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1363                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1364                                    }
1365    
1366                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1367                            }
1368                    }
1369                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1370                            _log.error(se, se);
1371    
1372                            throw se;
1373                    }
1374            }
1375    
1376            public static long importPortletInfoInBackground(
1377                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1378                    long groupId, java.lang.String portletId,
1379                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1380                    java.io.File file)
1381                    throws com.liferay.portal.kernel.exception.PortalException {
1382                    try {
1383                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1384                                            "importPortletInfoInBackground",
1385                                            _importPortletInfoInBackgroundParameterTypes40);
1386    
1387                            MethodHandler methodHandler = new MethodHandler(methodKey,
1388                                            taskName, plid, groupId, portletId, parameterMap, file);
1389    
1390                            Object returnObj = null;
1391    
1392                            try {
1393                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1394                            }
1395                            catch (Exception e) {
1396                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1397                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1398                                    }
1399    
1400                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1401                            }
1402    
1403                            return ((Long)returnObj).longValue();
1404                    }
1405                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1406                            _log.error(se, se);
1407    
1408                            throw se;
1409                    }
1410            }
1411    
1412            public static long importPortletInfoInBackground(
1413                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1414                    long groupId, java.lang.String portletId,
1415                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1416                    java.io.InputStream is)
1417                    throws com.liferay.portal.kernel.exception.PortalException {
1418                    try {
1419                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1420                                            "importPortletInfoInBackground",
1421                                            _importPortletInfoInBackgroundParameterTypes41);
1422    
1423                            MethodHandler methodHandler = new MethodHandler(methodKey,
1424                                            taskName, plid, groupId, portletId, parameterMap, is);
1425    
1426                            Object returnObj = null;
1427    
1428                            try {
1429                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1430                            }
1431                            catch (Exception e) {
1432                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1433                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1434                                    }
1435    
1436                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1437                            }
1438    
1439                            return ((Long)returnObj).longValue();
1440                    }
1441                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1442                            _log.error(se, se);
1443    
1444                            throw se;
1445                    }
1446            }
1447    
1448            public static void importPortletInfoInBackground(
1449                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1450                    java.lang.String portletId,
1451                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1452                    java.io.File file)
1453                    throws com.liferay.portal.kernel.exception.PortalException {
1454                    try {
1455                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1456                                            "importPortletInfoInBackground",
1457                                            _importPortletInfoInBackgroundParameterTypes42);
1458    
1459                            MethodHandler methodHandler = new MethodHandler(methodKey,
1460                                            taskName, portletId, parameterMap, file);
1461    
1462                            try {
1463                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1464                            }
1465                            catch (Exception e) {
1466                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1467                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1468                                    }
1469    
1470                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1471                            }
1472                    }
1473                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1474                            _log.error(se, se);
1475    
1476                            throw se;
1477                    }
1478            }
1479    
1480            public static void importPortletInfoInBackground(
1481                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1482                    java.lang.String portletId,
1483                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1484                    java.io.InputStream is)
1485                    throws com.liferay.portal.kernel.exception.PortalException {
1486                    try {
1487                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1488                                            "importPortletInfoInBackground",
1489                                            _importPortletInfoInBackgroundParameterTypes43);
1490    
1491                            MethodHandler methodHandler = new MethodHandler(methodKey,
1492                                            taskName, portletId, parameterMap, is);
1493    
1494                            try {
1495                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1496                            }
1497                            catch (Exception e) {
1498                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1499                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1500                                    }
1501    
1502                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1503                            }
1504                    }
1505                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1506                            _log.error(se, se);
1507    
1508                            throw se;
1509                    }
1510            }
1511    
1512            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1513                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1514                    long[] layoutIds,
1515                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1516                    java.lang.String scope, java.util.Date startDate,
1517                    java.util.Date endDate, java.lang.String groupName,
1518                    java.lang.String cronText, java.util.Date schedulerStartDate,
1519                    java.util.Date schedulerEndDate, java.lang.String description)
1520                    throws com.liferay.portal.kernel.exception.PortalException {
1521                    try {
1522                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1523                                            "schedulePublishToLive",
1524                                            _schedulePublishToLiveParameterTypes44);
1525    
1526                            MethodHandler methodHandler = new MethodHandler(methodKey,
1527                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1528                                            parameterMap, scope, startDate, endDate, groupName,
1529                                            cronText, schedulerStartDate, schedulerEndDate, description);
1530    
1531                            try {
1532                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1533                            }
1534                            catch (Exception e) {
1535                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1536                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1537                                    }
1538    
1539                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1540                            }
1541                    }
1542                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1543                            _log.error(se, se);
1544    
1545                            throw se;
1546                    }
1547            }
1548    
1549            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1550                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1551                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1552                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1553                    java.lang.String scope, java.util.Date startDate,
1554                    java.util.Date endDate, java.lang.String groupName,
1555                    java.lang.String cronText, java.util.Date schedulerStartDate,
1556                    java.util.Date schedulerEndDate, java.lang.String description)
1557                    throws com.liferay.portal.kernel.exception.PortalException {
1558                    try {
1559                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1560                                            "schedulePublishToLive",
1561                                            _schedulePublishToLiveParameterTypes45);
1562    
1563                            MethodHandler methodHandler = new MethodHandler(methodKey,
1564                                            sourceGroupId, targetGroupId, privateLayout, layoutIdMap,
1565                                            parameterMap, scope, startDate, endDate, groupName,
1566                                            cronText, schedulerStartDate, schedulerEndDate, description);
1567    
1568                            try {
1569                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1570                            }
1571                            catch (Exception e) {
1572                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1573                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1574                                    }
1575    
1576                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1577                            }
1578                    }
1579                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1580                            _log.error(se, se);
1581    
1582                            throw se;
1583                    }
1584            }
1585    
1586            public static void schedulePublishToRemote(HttpPrincipal httpPrincipal,
1587                    long sourceGroupId, boolean privateLayout,
1588                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1589                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1590                    java.lang.String remoteAddress, int remotePort,
1591                    java.lang.String remotePathContext, boolean secureConnection,
1592                    long remoteGroupId, boolean remotePrivateLayout,
1593                    java.util.Date startDate, java.util.Date endDate,
1594                    java.lang.String groupName, java.lang.String cronText,
1595                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1596                    java.lang.String description)
1597                    throws com.liferay.portal.kernel.exception.PortalException {
1598                    try {
1599                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1600                                            "schedulePublishToRemote",
1601                                            _schedulePublishToRemoteParameterTypes46);
1602    
1603                            MethodHandler methodHandler = new MethodHandler(methodKey,
1604                                            sourceGroupId, privateLayout, layoutIdMap, parameterMap,
1605                                            remoteAddress, remotePort, remotePathContext,
1606                                            secureConnection, remoteGroupId, remotePrivateLayout,
1607                                            startDate, endDate, groupName, cronText,
1608                                            schedulerStartDate, schedulerEndDate, description);
1609    
1610                            try {
1611                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1612                            }
1613                            catch (Exception e) {
1614                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1615                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1616                                    }
1617    
1618                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1619                            }
1620                    }
1621                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1622                            _log.error(se, se);
1623    
1624                            throw se;
1625                    }
1626            }
1627    
1628            public static void setLayouts(HttpPrincipal httpPrincipal, long groupId,
1629                    boolean privateLayout, long parentLayoutId, long[] layoutIds,
1630                    com.liferay.portal.service.ServiceContext serviceContext)
1631                    throws com.liferay.portal.kernel.exception.PortalException {
1632                    try {
1633                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1634                                            "setLayouts", _setLayoutsParameterTypes47);
1635    
1636                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1637                                            privateLayout, parentLayoutId, layoutIds, serviceContext);
1638    
1639                            try {
1640                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1641                            }
1642                            catch (Exception e) {
1643                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1644                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1645                                    }
1646    
1647                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1648                            }
1649                    }
1650                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1651                            _log.error(se, se);
1652    
1653                            throw se;
1654                    }
1655            }
1656    
1657            public static void unschedulePublishToLive(HttpPrincipal httpPrincipal,
1658                    long groupId, java.lang.String jobName, java.lang.String groupName)
1659                    throws com.liferay.portal.kernel.exception.PortalException {
1660                    try {
1661                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1662                                            "unschedulePublishToLive",
1663                                            _unschedulePublishToLiveParameterTypes48);
1664    
1665                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1666                                            jobName, groupName);
1667    
1668                            try {
1669                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1670                            }
1671                            catch (Exception e) {
1672                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1673                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1674                                    }
1675    
1676                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1677                            }
1678                    }
1679                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1680                            _log.error(se, se);
1681    
1682                            throw se;
1683                    }
1684            }
1685    
1686            public static void unschedulePublishToRemote(HttpPrincipal httpPrincipal,
1687                    long groupId, java.lang.String jobName, java.lang.String groupName)
1688                    throws com.liferay.portal.kernel.exception.PortalException {
1689                    try {
1690                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1691                                            "unschedulePublishToRemote",
1692                                            _unschedulePublishToRemoteParameterTypes49);
1693    
1694                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1695                                            jobName, groupName);
1696    
1697                            try {
1698                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1699                            }
1700                            catch (Exception e) {
1701                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1702                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1703                                    }
1704    
1705                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1706                            }
1707                    }
1708                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1709                            _log.error(se, se);
1710    
1711                            throw se;
1712                    }
1713            }
1714    
1715            public static com.liferay.portal.model.Layout updateIconImage(
1716                    HttpPrincipal httpPrincipal, long plid, byte[] bytes)
1717                    throws com.liferay.portal.kernel.exception.PortalException {
1718                    try {
1719                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1720                                            "updateIconImage", _updateIconImageParameterTypes50);
1721    
1722                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1723                                            bytes);
1724    
1725                            Object returnObj = null;
1726    
1727                            try {
1728                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1729                            }
1730                            catch (Exception e) {
1731                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1732                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1733                                    }
1734    
1735                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1736                            }
1737    
1738                            return (com.liferay.portal.model.Layout)returnObj;
1739                    }
1740                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1741                            _log.error(se, se);
1742    
1743                            throw se;
1744                    }
1745            }
1746    
1747            public static com.liferay.portal.model.Layout updateLayout(
1748                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1749                    long layoutId, long parentLayoutId,
1750                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1751                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1752                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1753                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1754                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1755                    java.lang.String type, boolean hidden,
1756                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
1757                    boolean iconImage, byte[] iconBytes,
1758                    com.liferay.portal.service.ServiceContext serviceContext)
1759                    throws com.liferay.portal.kernel.exception.PortalException {
1760                    try {
1761                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1762                                            "updateLayout", _updateLayoutParameterTypes51);
1763    
1764                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1765                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1766                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1767                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
1768                                            serviceContext);
1769    
1770                            Object returnObj = null;
1771    
1772                            try {
1773                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1774                            }
1775                            catch (Exception e) {
1776                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1777                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1778                                    }
1779    
1780                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1781                            }
1782    
1783                            return (com.liferay.portal.model.Layout)returnObj;
1784                    }
1785                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1786                            _log.error(se, se);
1787    
1788                            throw se;
1789                    }
1790            }
1791    
1792            public static com.liferay.portal.model.Layout updateLayout(
1793                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1794                    long layoutId, long parentLayoutId,
1795                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1796                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1797                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1798                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1799                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1800                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
1801                    java.lang.Boolean iconImage, byte[] iconBytes,
1802                    com.liferay.portal.service.ServiceContext serviceContext)
1803                    throws com.liferay.portal.kernel.exception.PortalException {
1804                    try {
1805                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1806                                            "updateLayout", _updateLayoutParameterTypes52);
1807    
1808                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1809                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1810                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1811                                            type, hidden, friendlyURL, iconImage, iconBytes,
1812                                            serviceContext);
1813    
1814                            Object returnObj = null;
1815    
1816                            try {
1817                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1818                            }
1819                            catch (Exception e) {
1820                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1821                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1822                                    }
1823    
1824                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1825                            }
1826    
1827                            return (com.liferay.portal.model.Layout)returnObj;
1828                    }
1829                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1830                            _log.error(se, se);
1831    
1832                            throw se;
1833                    }
1834            }
1835    
1836            public static com.liferay.portal.model.Layout updateLayout(
1837                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1838                    long layoutId, java.lang.String typeSettings)
1839                    throws com.liferay.portal.kernel.exception.PortalException {
1840                    try {
1841                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1842                                            "updateLayout", _updateLayoutParameterTypes53);
1843    
1844                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1845                                            privateLayout, layoutId, typeSettings);
1846    
1847                            Object returnObj = null;
1848    
1849                            try {
1850                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1851                            }
1852                            catch (Exception e) {
1853                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1854                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1855                                    }
1856    
1857                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1858                            }
1859    
1860                            return (com.liferay.portal.model.Layout)returnObj;
1861                    }
1862                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1863                            _log.error(se, se);
1864    
1865                            throw se;
1866                    }
1867            }
1868    
1869            public static com.liferay.portal.model.Layout updateLookAndFeel(
1870                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1871                    long layoutId, java.lang.String themeId,
1872                    java.lang.String colorSchemeId, java.lang.String css, boolean wapTheme)
1873                    throws com.liferay.portal.kernel.exception.PortalException {
1874                    try {
1875                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1876                                            "updateLookAndFeel", _updateLookAndFeelParameterTypes54);
1877    
1878                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1879                                            privateLayout, layoutId, themeId, colorSchemeId, css,
1880                                            wapTheme);
1881    
1882                            Object returnObj = null;
1883    
1884                            try {
1885                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1886                            }
1887                            catch (Exception e) {
1888                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1889                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1890                                    }
1891    
1892                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1893                            }
1894    
1895                            return (com.liferay.portal.model.Layout)returnObj;
1896                    }
1897                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1898                            _log.error(se, se);
1899    
1900                            throw se;
1901                    }
1902            }
1903    
1904            public static com.liferay.portal.model.Layout updateName(
1905                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1906                    long layoutId, java.lang.String name, java.lang.String languageId)
1907                    throws com.liferay.portal.kernel.exception.PortalException {
1908                    try {
1909                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1910                                            "updateName", _updateNameParameterTypes55);
1911    
1912                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1913                                            privateLayout, layoutId, name, languageId);
1914    
1915                            Object returnObj = null;
1916    
1917                            try {
1918                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1919                            }
1920                            catch (Exception e) {
1921                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1922                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1923                                    }
1924    
1925                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1926                            }
1927    
1928                            return (com.liferay.portal.model.Layout)returnObj;
1929                    }
1930                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1931                            _log.error(se, se);
1932    
1933                            throw se;
1934                    }
1935            }
1936    
1937            public static com.liferay.portal.model.Layout updateName(
1938                    HttpPrincipal httpPrincipal, long plid, java.lang.String name,
1939                    java.lang.String languageId)
1940                    throws com.liferay.portal.kernel.exception.PortalException {
1941                    try {
1942                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1943                                            "updateName", _updateNameParameterTypes56);
1944    
1945                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1946                                            name, languageId);
1947    
1948                            Object returnObj = null;
1949    
1950                            try {
1951                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1952                            }
1953                            catch (Exception e) {
1954                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1955                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1956                                    }
1957    
1958                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1959                            }
1960    
1961                            return (com.liferay.portal.model.Layout)returnObj;
1962                    }
1963                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1964                            _log.error(se, se);
1965    
1966                            throw se;
1967                    }
1968            }
1969    
1970            public static com.liferay.portal.model.Layout updateParentLayoutId(
1971                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1972                    long layoutId, long parentLayoutId)
1973                    throws com.liferay.portal.kernel.exception.PortalException {
1974                    try {
1975                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1976                                            "updateParentLayoutId",
1977                                            _updateParentLayoutIdParameterTypes57);
1978    
1979                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1980                                            privateLayout, layoutId, parentLayoutId);
1981    
1982                            Object returnObj = null;
1983    
1984                            try {
1985                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1986                            }
1987                            catch (Exception e) {
1988                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1989                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1990                                    }
1991    
1992                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1993                            }
1994    
1995                            return (com.liferay.portal.model.Layout)returnObj;
1996                    }
1997                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1998                            _log.error(se, se);
1999    
2000                            throw se;
2001                    }
2002            }
2003    
2004            public static com.liferay.portal.model.Layout updateParentLayoutId(
2005                    HttpPrincipal httpPrincipal, long plid, long parentPlid)
2006                    throws com.liferay.portal.kernel.exception.PortalException {
2007                    try {
2008                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2009                                            "updateParentLayoutId",
2010                                            _updateParentLayoutIdParameterTypes58);
2011    
2012                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2013                                            parentPlid);
2014    
2015                            Object returnObj = null;
2016    
2017                            try {
2018                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2019                            }
2020                            catch (Exception e) {
2021                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2022                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2023                                    }
2024    
2025                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2026                            }
2027    
2028                            return (com.liferay.portal.model.Layout)returnObj;
2029                    }
2030                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2031                            _log.error(se, se);
2032    
2033                            throw se;
2034                    }
2035            }
2036    
2037            public static com.liferay.portal.model.Layout updateParentLayoutIdAndPriority(
2038                    HttpPrincipal httpPrincipal, long plid, long parentPlid, int priority)
2039                    throws com.liferay.portal.kernel.exception.PortalException {
2040                    try {
2041                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2042                                            "updateParentLayoutIdAndPriority",
2043                                            _updateParentLayoutIdAndPriorityParameterTypes59);
2044    
2045                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2046                                            parentPlid, priority);
2047    
2048                            Object returnObj = null;
2049    
2050                            try {
2051                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2052                            }
2053                            catch (Exception e) {
2054                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2055                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2056                                    }
2057    
2058                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2059                            }
2060    
2061                            return (com.liferay.portal.model.Layout)returnObj;
2062                    }
2063                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2064                            _log.error(se, se);
2065    
2066                            throw se;
2067                    }
2068            }
2069    
2070            public static com.liferay.portal.model.Layout updatePriority(
2071                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2072                    long layoutId, int priority)
2073                    throws com.liferay.portal.kernel.exception.PortalException {
2074                    try {
2075                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2076                                            "updatePriority", _updatePriorityParameterTypes60);
2077    
2078                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2079                                            privateLayout, layoutId, priority);
2080    
2081                            Object returnObj = null;
2082    
2083                            try {
2084                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2085                            }
2086                            catch (Exception e) {
2087                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2088                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2089                                    }
2090    
2091                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2092                            }
2093    
2094                            return (com.liferay.portal.model.Layout)returnObj;
2095                    }
2096                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2097                            _log.error(se, se);
2098    
2099                            throw se;
2100                    }
2101            }
2102    
2103            public static com.liferay.portal.model.Layout updatePriority(
2104                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2105                    long layoutId, long nextLayoutId, long previousLayoutId)
2106                    throws com.liferay.portal.kernel.exception.PortalException {
2107                    try {
2108                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2109                                            "updatePriority", _updatePriorityParameterTypes61);
2110    
2111                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2112                                            privateLayout, layoutId, nextLayoutId, previousLayoutId);
2113    
2114                            Object returnObj = null;
2115    
2116                            try {
2117                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2118                            }
2119                            catch (Exception e) {
2120                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2121                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2122                                    }
2123    
2124                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2125                            }
2126    
2127                            return (com.liferay.portal.model.Layout)returnObj;
2128                    }
2129                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2130                            _log.error(se, se);
2131    
2132                            throw se;
2133                    }
2134            }
2135    
2136            public static com.liferay.portal.model.Layout updatePriority(
2137                    HttpPrincipal httpPrincipal, long plid, int priority)
2138                    throws com.liferay.portal.kernel.exception.PortalException {
2139                    try {
2140                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2141                                            "updatePriority", _updatePriorityParameterTypes62);
2142    
2143                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2144                                            priority);
2145    
2146                            Object returnObj = null;
2147    
2148                            try {
2149                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2150                            }
2151                            catch (Exception e) {
2152                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2153                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2154                                    }
2155    
2156                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2157                            }
2158    
2159                            return (com.liferay.portal.model.Layout)returnObj;
2160                    }
2161                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2162                            _log.error(se, se);
2163    
2164                            throw se;
2165                    }
2166            }
2167    
2168            public static com.liferay.portal.kernel.lar.MissingReferences validateImportLayoutsFile(
2169                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2170                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2171                    java.io.File file)
2172                    throws com.liferay.portal.kernel.exception.PortalException {
2173                    try {
2174                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2175                                            "validateImportLayoutsFile",
2176                                            _validateImportLayoutsFileParameterTypes63);
2177    
2178                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2179                                            privateLayout, parameterMap, file);
2180    
2181                            Object returnObj = null;
2182    
2183                            try {
2184                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2185                            }
2186                            catch (Exception e) {
2187                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2188                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2189                                    }
2190    
2191                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2192                            }
2193    
2194                            return (com.liferay.portal.kernel.lar.MissingReferences)returnObj;
2195                    }
2196                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2197                            _log.error(se, se);
2198    
2199                            throw se;
2200                    }
2201            }
2202    
2203            public static com.liferay.portal.kernel.lar.MissingReferences validateImportLayoutsFile(
2204                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2205                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2206                    java.io.InputStream inputStream)
2207                    throws com.liferay.portal.kernel.exception.PortalException {
2208                    try {
2209                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2210                                            "validateImportLayoutsFile",
2211                                            _validateImportLayoutsFileParameterTypes64);
2212    
2213                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2214                                            privateLayout, parameterMap, inputStream);
2215    
2216                            Object returnObj = null;
2217    
2218                            try {
2219                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2220                            }
2221                            catch (Exception e) {
2222                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2223                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2224                                    }
2225    
2226                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2227                            }
2228    
2229                            return (com.liferay.portal.kernel.lar.MissingReferences)returnObj;
2230                    }
2231                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2232                            _log.error(se, se);
2233    
2234                            throw se;
2235                    }
2236            }
2237    
2238            public static com.liferay.portal.kernel.lar.MissingReferences validateImportPortletInfo(
2239                    HttpPrincipal httpPrincipal, long plid, long groupId,
2240                    java.lang.String portletId,
2241                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2242                    java.io.File file)
2243                    throws com.liferay.portal.kernel.exception.PortalException {
2244                    try {
2245                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2246                                            "validateImportPortletInfo",
2247                                            _validateImportPortletInfoParameterTypes65);
2248    
2249                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2250                                            groupId, portletId, parameterMap, file);
2251    
2252                            Object returnObj = null;
2253    
2254                            try {
2255                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2256                            }
2257                            catch (Exception e) {
2258                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2259                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2260                                    }
2261    
2262                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2263                            }
2264    
2265                            return (com.liferay.portal.kernel.lar.MissingReferences)returnObj;
2266                    }
2267                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2268                            _log.error(se, se);
2269    
2270                            throw se;
2271                    }
2272            }
2273    
2274            public static com.liferay.portal.kernel.lar.MissingReferences validateImportPortletInfo(
2275                    HttpPrincipal httpPrincipal, long plid, long groupId,
2276                    java.lang.String portletId,
2277                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2278                    java.io.InputStream inputStream)
2279                    throws com.liferay.portal.kernel.exception.PortalException {
2280                    try {
2281                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2282                                            "validateImportPortletInfo",
2283                                            _validateImportPortletInfoParameterTypes66);
2284    
2285                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2286                                            groupId, portletId, parameterMap, inputStream);
2287    
2288                            Object returnObj = null;
2289    
2290                            try {
2291                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2292                            }
2293                            catch (Exception e) {
2294                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2295                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2296                                    }
2297    
2298                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2299                            }
2300    
2301                            return (com.liferay.portal.kernel.lar.MissingReferences)returnObj;
2302                    }
2303                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2304                            _log.error(se, se);
2305    
2306                            throw se;
2307                    }
2308            }
2309    
2310            private static Log _log = LogFactoryUtil.getLog(LayoutServiceHttp.class);
2311            private static final Class<?>[] _addLayoutParameterTypes0 = new Class[] {
2312                            long.class, boolean.class, long.class, java.util.Map.class,
2313                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2314                            java.util.Map.class, java.lang.String.class, boolean.class,
2315                            java.lang.String.class,
2316                            com.liferay.portal.service.ServiceContext.class
2317                    };
2318            private static final Class<?>[] _addLayoutParameterTypes1 = new Class[] {
2319                            long.class, boolean.class, long.class, java.util.Map.class,
2320                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2321                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2322                            boolean.class, java.util.Map.class,
2323                            com.liferay.portal.service.ServiceContext.class
2324                    };
2325            private static final Class<?>[] _addLayoutParameterTypes2 = new Class[] {
2326                            long.class, boolean.class, long.class, java.lang.String.class,
2327                            java.lang.String.class, java.lang.String.class,
2328                            java.lang.String.class, boolean.class, java.lang.String.class,
2329                            com.liferay.portal.service.ServiceContext.class
2330                    };
2331            private static final Class<?>[] _addTempFileEntryParameterTypes3 = new Class[] {
2332                            long.class, java.lang.String.class, java.lang.String.class,
2333                            java.io.InputStream.class, java.lang.String.class
2334                    };
2335            private static final Class<?>[] _deleteLayoutParameterTypes4 = new Class[] {
2336                            long.class, boolean.class, long.class,
2337                            com.liferay.portal.service.ServiceContext.class
2338                    };
2339            private static final Class<?>[] _deleteLayoutParameterTypes5 = new Class[] {
2340                            long.class, com.liferay.portal.service.ServiceContext.class
2341                    };
2342            private static final Class<?>[] _deleteTempFileEntryParameterTypes6 = new Class[] {
2343                            long.class, java.lang.String.class, java.lang.String.class
2344                    };
2345            private static final Class<?>[] _exportLayoutsParameterTypes7 = new Class[] {
2346                            long.class, boolean.class, long[].class, java.util.Map.class,
2347                            java.util.Date.class, java.util.Date.class
2348                    };
2349            private static final Class<?>[] _exportLayoutsParameterTypes8 = new Class[] {
2350                            long.class, boolean.class, java.util.Map.class, java.util.Date.class,
2351                            java.util.Date.class
2352                    };
2353            private static final Class<?>[] _exportLayoutsAsFileParameterTypes9 = new Class[] {
2354                            long.class, boolean.class, long[].class, java.util.Map.class,
2355                            java.util.Date.class, java.util.Date.class
2356                    };
2357            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes10 =
2358                    new Class[] { com.liferay.portal.model.ExportImportConfiguration.class };
2359            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes11 =
2360                    new Class[] { long.class };
2361            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes12 =
2362                    new Class[] {
2363                            java.lang.String.class, long.class, boolean.class, long[].class,
2364                            java.util.Map.class, java.util.Date.class, java.util.Date.class
2365                    };
2366            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes13 =
2367                    new Class[] {
2368                            java.lang.String.class, long.class, boolean.class, long[].class,
2369                            java.util.Map.class, java.util.Date.class, java.util.Date.class,
2370                            java.lang.String.class
2371                    };
2372            private static final Class<?>[] _exportPortletInfoParameterTypes14 = new Class[] {
2373                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2374                            java.util.Date.class, java.util.Date.class
2375                    };
2376            private static final Class<?>[] _exportPortletInfoParameterTypes15 = new Class[] {
2377                            long.class, java.lang.String.class, java.util.Map.class,
2378                            java.util.Date.class, java.util.Date.class
2379                    };
2380            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes16 = new Class[] {
2381                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2382                            java.util.Date.class, java.util.Date.class
2383                    };
2384            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes17 = new Class[] {
2385                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2386                            java.util.Date.class
2387                    };
2388            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes18 =
2389                    new Class[] {
2390                            java.lang.String.class, long.class, long.class,
2391                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2392                            java.util.Date.class, java.lang.String.class
2393                    };
2394            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes19 =
2395                    new Class[] {
2396                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2397                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2398                    };
2399            private static final Class<?>[] _getAncestorLayoutsParameterTypes20 = new Class[] {
2400                            long.class
2401                    };
2402            private static final Class<?>[] _getDefaultPlidParameterTypes21 = new Class[] {
2403                            long.class, long.class, boolean.class, java.lang.String.class
2404                    };
2405            private static final Class<?>[] _getDefaultPlidParameterTypes22 = new Class[] {
2406                            long.class, long.class, java.lang.String.class
2407                    };
2408            private static final Class<?>[] _getLayoutByUuidAndGroupIdParameterTypes23 = new Class[] {
2409                            java.lang.String.class, long.class, boolean.class
2410                    };
2411            private static final Class<?>[] _getLayoutNameParameterTypes24 = new Class[] {
2412                            long.class, boolean.class, long.class, java.lang.String.class
2413                    };
2414            private static final Class<?>[] _getLayoutReferencesParameterTypes25 = new Class[] {
2415                            long.class, java.lang.String.class, java.lang.String.class,
2416                            java.lang.String.class
2417                    };
2418            private static final Class<?>[] _getLayoutsParameterTypes26 = new Class[] {
2419                            long.class, boolean.class
2420                    };
2421            private static final Class<?>[] _getLayoutsParameterTypes27 = new Class[] {
2422                            long.class, boolean.class, long.class
2423                    };
2424            private static final Class<?>[] _getLayoutsParameterTypes28 = new Class[] {
2425                            long.class, boolean.class, long.class, boolean.class, int.class,
2426                            int.class
2427                    };
2428            private static final Class<?>[] _getLayoutsCountParameterTypes29 = new Class[] {
2429                            long.class, boolean.class, long.class
2430                    };
2431            private static final Class<?>[] _getTempFileNamesParameterTypes30 = new Class[] {
2432                            long.class, java.lang.String.class
2433                    };
2434            private static final Class<?>[] _importLayoutsParameterTypes31 = new Class[] {
2435                            long.class, boolean.class, java.util.Map.class, byte[].class
2436                    };
2437            private static final Class<?>[] _importLayoutsParameterTypes32 = new Class[] {
2438                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2439                    };
2440            private static final Class<?>[] _importLayoutsParameterTypes33 = new Class[] {
2441                            long.class, boolean.class, java.util.Map.class,
2442                            java.io.InputStream.class
2443                    };
2444            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes34 = new Class[] {
2445                            java.lang.String.class, long.class, boolean.class,
2446                            java.util.Map.class, java.io.File.class
2447                    };
2448            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes35 = new Class[] {
2449                            java.lang.String.class, long.class, boolean.class,
2450                            java.util.Map.class, java.io.InputStream.class
2451                    };
2452            private static final Class<?>[] _importPortletInfoParameterTypes36 = new Class[] {
2453                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2454                            java.io.File.class
2455                    };
2456            private static final Class<?>[] _importPortletInfoParameterTypes37 = new Class[] {
2457                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2458                            java.io.InputStream.class
2459                    };
2460            private static final Class<?>[] _importPortletInfoParameterTypes38 = new Class[] {
2461                            java.lang.String.class, java.util.Map.class, java.io.File.class
2462                    };
2463            private static final Class<?>[] _importPortletInfoParameterTypes39 = new Class[] {
2464                            java.lang.String.class, java.util.Map.class,
2465                            java.io.InputStream.class
2466                    };
2467            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes40 =
2468                    new Class[] {
2469                            java.lang.String.class, long.class, long.class,
2470                            java.lang.String.class, java.util.Map.class, java.io.File.class
2471                    };
2472            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes41 =
2473                    new Class[] {
2474                            java.lang.String.class, long.class, long.class,
2475                            java.lang.String.class, java.util.Map.class,
2476                            java.io.InputStream.class
2477                    };
2478            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes42 =
2479                    new Class[] {
2480                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2481                            java.io.File.class
2482                    };
2483            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes43 =
2484                    new Class[] {
2485                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2486                            java.io.InputStream.class
2487                    };
2488            private static final Class<?>[] _schedulePublishToLiveParameterTypes44 = new Class[] {
2489                            long.class, long.class, boolean.class, long[].class,
2490                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2491                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2492                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2493                    };
2494            private static final Class<?>[] _schedulePublishToLiveParameterTypes45 = new Class[] {
2495                            long.class, long.class, boolean.class, java.util.Map.class,
2496                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2497                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2498                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2499                    };
2500            private static final Class<?>[] _schedulePublishToRemoteParameterTypes46 = new Class[] {
2501                            long.class, boolean.class, java.util.Map.class, java.util.Map.class,
2502                            java.lang.String.class, int.class, java.lang.String.class,
2503                            boolean.class, long.class, boolean.class, java.util.Date.class,
2504                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2505                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2506                    };
2507            private static final Class<?>[] _setLayoutsParameterTypes47 = new Class[] {
2508                            long.class, boolean.class, long.class, long[].class,
2509                            com.liferay.portal.service.ServiceContext.class
2510                    };
2511            private static final Class<?>[] _unschedulePublishToLiveParameterTypes48 = new Class[] {
2512                            long.class, java.lang.String.class, java.lang.String.class
2513                    };
2514            private static final Class<?>[] _unschedulePublishToRemoteParameterTypes49 = new Class[] {
2515                            long.class, java.lang.String.class, java.lang.String.class
2516                    };
2517            private static final Class<?>[] _updateIconImageParameterTypes50 = new Class[] {
2518                            long.class, byte[].class
2519                    };
2520            private static final Class<?>[] _updateLayoutParameterTypes51 = new Class[] {
2521                            long.class, boolean.class, long.class, long.class,
2522                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2523                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2524                            boolean.class, java.util.Map.class, boolean.class, byte[].class,
2525                            com.liferay.portal.service.ServiceContext.class
2526                    };
2527            private static final Class<?>[] _updateLayoutParameterTypes52 = new Class[] {
2528                            long.class, boolean.class, long.class, long.class,
2529                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2530                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2531                            boolean.class, java.lang.String.class, java.lang.Boolean.class,
2532                            byte[].class, com.liferay.portal.service.ServiceContext.class
2533                    };
2534            private static final Class<?>[] _updateLayoutParameterTypes53 = new Class[] {
2535                            long.class, boolean.class, long.class, java.lang.String.class
2536                    };
2537            private static final Class<?>[] _updateLookAndFeelParameterTypes54 = new Class[] {
2538                            long.class, boolean.class, long.class, java.lang.String.class,
2539                            java.lang.String.class, java.lang.String.class, boolean.class
2540                    };
2541            private static final Class<?>[] _updateNameParameterTypes55 = new Class[] {
2542                            long.class, boolean.class, long.class, java.lang.String.class,
2543                            java.lang.String.class
2544                    };
2545            private static final Class<?>[] _updateNameParameterTypes56 = new Class[] {
2546                            long.class, java.lang.String.class, java.lang.String.class
2547                    };
2548            private static final Class<?>[] _updateParentLayoutIdParameterTypes57 = new Class[] {
2549                            long.class, boolean.class, long.class, long.class
2550                    };
2551            private static final Class<?>[] _updateParentLayoutIdParameterTypes58 = new Class[] {
2552                            long.class, long.class
2553                    };
2554            private static final Class<?>[] _updateParentLayoutIdAndPriorityParameterTypes59 =
2555                    new Class[] { long.class, long.class, int.class };
2556            private static final Class<?>[] _updatePriorityParameterTypes60 = new Class[] {
2557                            long.class, boolean.class, long.class, int.class
2558                    };
2559            private static final Class<?>[] _updatePriorityParameterTypes61 = new Class[] {
2560                            long.class, boolean.class, long.class, long.class, long.class
2561                    };
2562            private static final Class<?>[] _updatePriorityParameterTypes62 = new Class[] {
2563                            long.class, int.class
2564                    };
2565            private static final Class<?>[] _validateImportLayoutsFileParameterTypes63 = new Class[] {
2566                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2567                    };
2568            private static final Class<?>[] _validateImportLayoutsFileParameterTypes64 = new Class[] {
2569                            long.class, boolean.class, java.util.Map.class,
2570                            java.io.InputStream.class
2571                    };
2572            private static final Class<?>[] _validateImportPortletInfoParameterTypes65 = new Class[] {
2573                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2574                            java.io.File.class
2575                    };
2576            private static final Class<?>[] _validateImportPortletInfoParameterTypes66 = new Class[] {
2577                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2578                            java.io.InputStream.class
2579                    };
2580    }