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 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 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 HttpPrincipal
051     * @see 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,
367                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration)
368                    throws com.liferay.portal.kernel.exception.PortalException {
369                    try {
370                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
371                                            "exportLayoutsAsFile", _exportLayoutsAsFileParameterTypes9);
372    
373                            MethodHandler methodHandler = new MethodHandler(methodKey,
374                                            exportImportConfiguration);
375    
376                            Object returnObj = null;
377    
378                            try {
379                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
380                            }
381                            catch (Exception e) {
382                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
383                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
384                                    }
385    
386                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
387                            }
388    
389                            return (java.io.File)returnObj;
390                    }
391                    catch (com.liferay.portal.kernel.exception.SystemException se) {
392                            _log.error(se, se);
393    
394                            throw se;
395                    }
396            }
397    
398            public static java.io.File exportLayoutsAsFile(
399                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
400                    long[] layoutIds,
401                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
402                    java.util.Date startDate, java.util.Date endDate)
403                    throws com.liferay.portal.kernel.exception.PortalException {
404                    try {
405                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
406                                            "exportLayoutsAsFile", _exportLayoutsAsFileParameterTypes10);
407    
408                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
409                                            privateLayout, layoutIds, parameterMap, startDate, endDate);
410    
411                            Object returnObj = null;
412    
413                            try {
414                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
415                            }
416                            catch (Exception e) {
417                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
418                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
419                                    }
420    
421                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
422                            }
423    
424                            return (java.io.File)returnObj;
425                    }
426                    catch (com.liferay.portal.kernel.exception.SystemException se) {
427                            _log.error(se, se);
428    
429                            throw se;
430                    }
431            }
432    
433            public static long exportLayoutsAsFileInBackground(
434                    HttpPrincipal httpPrincipal,
435                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration)
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                                            exportImportConfiguration);
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, long exportImportConfigurationId)
469                    throws com.liferay.portal.kernel.exception.PortalException {
470                    try {
471                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
472                                            "exportLayoutsAsFileInBackground",
473                                            _exportLayoutsAsFileInBackgroundParameterTypes12);
474    
475                            MethodHandler methodHandler = new MethodHandler(methodKey,
476                                            exportImportConfigurationId);
477    
478                            Object returnObj = null;
479    
480                            try {
481                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
482                            }
483                            catch (Exception e) {
484                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
485                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
486                                    }
487    
488                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
489                            }
490    
491                            return ((Long)returnObj).longValue();
492                    }
493                    catch (com.liferay.portal.kernel.exception.SystemException se) {
494                            _log.error(se, se);
495    
496                            throw se;
497                    }
498            }
499    
500            public static long exportLayoutsAsFileInBackground(
501                    HttpPrincipal httpPrincipal, java.lang.String taskName, long groupId,
502                    boolean privateLayout, long[] layoutIds,
503                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
504                    java.util.Date startDate, java.util.Date endDate)
505                    throws com.liferay.portal.kernel.exception.PortalException {
506                    try {
507                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
508                                            "exportLayoutsAsFileInBackground",
509                                            _exportLayoutsAsFileInBackgroundParameterTypes13);
510    
511                            MethodHandler methodHandler = new MethodHandler(methodKey,
512                                            taskName, groupId, privateLayout, layoutIds, parameterMap,
513                                            startDate, endDate);
514    
515                            Object returnObj = null;
516    
517                            try {
518                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
519                            }
520                            catch (Exception e) {
521                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
522                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
523                                    }
524    
525                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
526                            }
527    
528                            return ((Long)returnObj).longValue();
529                    }
530                    catch (com.liferay.portal.kernel.exception.SystemException se) {
531                            _log.error(se, se);
532    
533                            throw se;
534                    }
535            }
536    
537            public static long exportLayoutsAsFileInBackground(
538                    HttpPrincipal httpPrincipal, java.lang.String taskName, long groupId,
539                    boolean privateLayout, long[] layoutIds,
540                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
541                    java.util.Date startDate, java.util.Date endDate,
542                    java.lang.String fileName)
543                    throws com.liferay.portal.kernel.exception.PortalException {
544                    try {
545                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
546                                            "exportLayoutsAsFileInBackground",
547                                            _exportLayoutsAsFileInBackgroundParameterTypes14);
548    
549                            MethodHandler methodHandler = new MethodHandler(methodKey,
550                                            taskName, groupId, privateLayout, layoutIds, parameterMap,
551                                            startDate, endDate, fileName);
552    
553                            Object returnObj = null;
554    
555                            try {
556                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
557                            }
558                            catch (Exception e) {
559                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
560                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
561                                    }
562    
563                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
564                            }
565    
566                            return ((Long)returnObj).longValue();
567                    }
568                    catch (com.liferay.portal.kernel.exception.SystemException se) {
569                            _log.error(se, se);
570    
571                            throw se;
572                    }
573            }
574    
575            public static byte[] exportPortletInfo(HttpPrincipal httpPrincipal,
576                    long plid, long groupId, java.lang.String portletId,
577                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
578                    java.util.Date startDate, java.util.Date endDate)
579                    throws com.liferay.portal.kernel.exception.PortalException {
580                    try {
581                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
582                                            "exportPortletInfo", _exportPortletInfoParameterTypes15);
583    
584                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
585                                            groupId, portletId, parameterMap, startDate, endDate);
586    
587                            Object returnObj = null;
588    
589                            try {
590                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
591                            }
592                            catch (Exception e) {
593                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
594                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
595                                    }
596    
597                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
598                            }
599    
600                            return (byte[])returnObj;
601                    }
602                    catch (com.liferay.portal.kernel.exception.SystemException se) {
603                            _log.error(se, se);
604    
605                            throw se;
606                    }
607            }
608    
609            public static byte[] exportPortletInfo(HttpPrincipal httpPrincipal,
610                    long companyId, java.lang.String portletId,
611                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
612                    java.util.Date startDate, java.util.Date endDate)
613                    throws com.liferay.portal.kernel.exception.PortalException {
614                    try {
615                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
616                                            "exportPortletInfo", _exportPortletInfoParameterTypes16);
617    
618                            MethodHandler methodHandler = new MethodHandler(methodKey,
619                                            companyId, portletId, parameterMap, startDate, endDate);
620    
621                            Object returnObj = null;
622    
623                            try {
624                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
625                            }
626                            catch (Exception e) {
627                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
628                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
629                                    }
630    
631                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
632                            }
633    
634                            return (byte[])returnObj;
635                    }
636                    catch (com.liferay.portal.kernel.exception.SystemException se) {
637                            _log.error(se, se);
638    
639                            throw se;
640                    }
641            }
642    
643            public static java.io.File exportPortletInfoAsFile(
644                    HttpPrincipal httpPrincipal,
645                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration)
646                    throws com.liferay.portal.kernel.exception.PortalException {
647                    try {
648                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
649                                            "exportPortletInfoAsFile",
650                                            _exportPortletInfoAsFileParameterTypes17);
651    
652                            MethodHandler methodHandler = new MethodHandler(methodKey,
653                                            exportImportConfiguration);
654    
655                            Object returnObj = null;
656    
657                            try {
658                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
659                            }
660                            catch (Exception e) {
661                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
662                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
663                                    }
664    
665                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
666                            }
667    
668                            return (java.io.File)returnObj;
669                    }
670                    catch (com.liferay.portal.kernel.exception.SystemException se) {
671                            _log.error(se, se);
672    
673                            throw se;
674                    }
675            }
676    
677            public static java.io.File exportPortletInfoAsFile(
678                    HttpPrincipal httpPrincipal, long plid, long groupId,
679                    java.lang.String portletId,
680                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
681                    java.util.Date startDate, java.util.Date endDate)
682                    throws com.liferay.portal.kernel.exception.PortalException {
683                    try {
684                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
685                                            "exportPortletInfoAsFile",
686                                            _exportPortletInfoAsFileParameterTypes18);
687    
688                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
689                                            groupId, portletId, parameterMap, startDate, endDate);
690    
691                            Object returnObj = null;
692    
693                            try {
694                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
695                            }
696                            catch (Exception e) {
697                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
698                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
699                                    }
700    
701                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
702                            }
703    
704                            return (java.io.File)returnObj;
705                    }
706                    catch (com.liferay.portal.kernel.exception.SystemException se) {
707                            _log.error(se, se);
708    
709                            throw se;
710                    }
711            }
712    
713            public static java.io.File exportPortletInfoAsFile(
714                    HttpPrincipal httpPrincipal, java.lang.String portletId,
715                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
716                    java.util.Date startDate, java.util.Date endDate)
717                    throws com.liferay.portal.kernel.exception.PortalException {
718                    try {
719                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
720                                            "exportPortletInfoAsFile",
721                                            _exportPortletInfoAsFileParameterTypes19);
722    
723                            MethodHandler methodHandler = new MethodHandler(methodKey,
724                                            portletId, parameterMap, startDate, endDate);
725    
726                            Object returnObj = null;
727    
728                            try {
729                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
730                            }
731                            catch (Exception e) {
732                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
733                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
734                                    }
735    
736                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
737                            }
738    
739                            return (java.io.File)returnObj;
740                    }
741                    catch (com.liferay.portal.kernel.exception.SystemException se) {
742                            _log.error(se, se);
743    
744                            throw se;
745                    }
746            }
747    
748            public static long exportPortletInfoAsFileInBackground(
749                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
750                    long groupId, java.lang.String portletId,
751                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
752                    java.util.Date startDate, java.util.Date endDate,
753                    java.lang.String fileName)
754                    throws com.liferay.portal.kernel.exception.PortalException {
755                    try {
756                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
757                                            "exportPortletInfoAsFileInBackground",
758                                            _exportPortletInfoAsFileInBackgroundParameterTypes20);
759    
760                            MethodHandler methodHandler = new MethodHandler(methodKey,
761                                            taskName, plid, groupId, portletId, parameterMap,
762                                            startDate, endDate, fileName);
763    
764                            Object returnObj = null;
765    
766                            try {
767                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
768                            }
769                            catch (Exception e) {
770                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
771                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
772                                    }
773    
774                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
775                            }
776    
777                            return ((Long)returnObj).longValue();
778                    }
779                    catch (com.liferay.portal.kernel.exception.SystemException se) {
780                            _log.error(se, se);
781    
782                            throw se;
783                    }
784            }
785    
786            public static long exportPortletInfoAsFileInBackground(
787                    HttpPrincipal httpPrincipal, java.lang.String taskName,
788                    java.lang.String portletId,
789                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
790                    java.util.Date startDate, java.util.Date endDate,
791                    java.lang.String fileName)
792                    throws com.liferay.portal.kernel.exception.PortalException {
793                    try {
794                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
795                                            "exportPortletInfoAsFileInBackground",
796                                            _exportPortletInfoAsFileInBackgroundParameterTypes21);
797    
798                            MethodHandler methodHandler = new MethodHandler(methodKey,
799                                            taskName, portletId, parameterMap, startDate, endDate,
800                                            fileName);
801    
802                            Object returnObj = null;
803    
804                            try {
805                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
806                            }
807                            catch (Exception e) {
808                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
809                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
810                                    }
811    
812                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
813                            }
814    
815                            return ((Long)returnObj).longValue();
816                    }
817                    catch (com.liferay.portal.kernel.exception.SystemException se) {
818                            _log.error(se, se);
819    
820                            throw se;
821                    }
822            }
823    
824            public static java.util.List<com.liferay.portal.model.Layout> getAncestorLayouts(
825                    HttpPrincipal httpPrincipal, long plid)
826                    throws com.liferay.portal.kernel.exception.PortalException {
827                    try {
828                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
829                                            "getAncestorLayouts", _getAncestorLayoutsParameterTypes22);
830    
831                            MethodHandler methodHandler = new MethodHandler(methodKey, plid);
832    
833                            Object returnObj = null;
834    
835                            try {
836                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
837                            }
838                            catch (Exception e) {
839                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
840                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
841                                    }
842    
843                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
844                            }
845    
846                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
847                    }
848                    catch (com.liferay.portal.kernel.exception.SystemException se) {
849                            _log.error(se, se);
850    
851                            throw se;
852                    }
853            }
854    
855            public static long getDefaultPlid(HttpPrincipal httpPrincipal,
856                    long groupId, long scopeGroupId, boolean privateLayout,
857                    java.lang.String portletId)
858                    throws com.liferay.portal.kernel.exception.PortalException {
859                    try {
860                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
861                                            "getDefaultPlid", _getDefaultPlidParameterTypes23);
862    
863                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
864                                            scopeGroupId, privateLayout, portletId);
865    
866                            Object returnObj = null;
867    
868                            try {
869                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
870                            }
871                            catch (Exception e) {
872                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
873                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
874                                    }
875    
876                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
877                            }
878    
879                            return ((Long)returnObj).longValue();
880                    }
881                    catch (com.liferay.portal.kernel.exception.SystemException se) {
882                            _log.error(se, se);
883    
884                            throw se;
885                    }
886            }
887    
888            public static long getDefaultPlid(HttpPrincipal httpPrincipal,
889                    long groupId, long scopeGroupId, java.lang.String portletId)
890                    throws com.liferay.portal.kernel.exception.PortalException {
891                    try {
892                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
893                                            "getDefaultPlid", _getDefaultPlidParameterTypes24);
894    
895                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
896                                            scopeGroupId, portletId);
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 ((Long)returnObj).longValue();
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.Layout getLayoutByUuidAndGroupId(
921                    HttpPrincipal httpPrincipal, java.lang.String uuid, long groupId,
922                    boolean privateLayout)
923                    throws com.liferay.portal.kernel.exception.PortalException {
924                    try {
925                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
926                                            "getLayoutByUuidAndGroupId",
927                                            _getLayoutByUuidAndGroupIdParameterTypes25);
928    
929                            MethodHandler methodHandler = new MethodHandler(methodKey, uuid,
930                                            groupId, privateLayout);
931    
932                            Object returnObj = null;
933    
934                            try {
935                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
936                            }
937                            catch (Exception e) {
938                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
939                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
940                                    }
941    
942                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
943                            }
944    
945                            return (com.liferay.portal.model.Layout)returnObj;
946                    }
947                    catch (com.liferay.portal.kernel.exception.SystemException se) {
948                            _log.error(se, se);
949    
950                            throw se;
951                    }
952            }
953    
954            public static java.lang.String getLayoutName(HttpPrincipal httpPrincipal,
955                    long groupId, boolean privateLayout, long layoutId,
956                    java.lang.String languageId)
957                    throws com.liferay.portal.kernel.exception.PortalException {
958                    try {
959                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
960                                            "getLayoutName", _getLayoutNameParameterTypes26);
961    
962                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
963                                            privateLayout, layoutId, languageId);
964    
965                            Object returnObj = null;
966    
967                            try {
968                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
969                            }
970                            catch (Exception e) {
971                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
972                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
973                                    }
974    
975                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
976                            }
977    
978                            return (java.lang.String)returnObj;
979                    }
980                    catch (com.liferay.portal.kernel.exception.SystemException se) {
981                            _log.error(se, se);
982    
983                            throw se;
984                    }
985            }
986    
987            public static com.liferay.portal.model.LayoutReference[] getLayoutReferences(
988                    HttpPrincipal httpPrincipal, long companyId,
989                    java.lang.String portletId, java.lang.String preferencesKey,
990                    java.lang.String preferencesValue) {
991                    try {
992                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
993                                            "getLayoutReferences", _getLayoutReferencesParameterTypes27);
994    
995                            MethodHandler methodHandler = new MethodHandler(methodKey,
996                                            companyId, portletId, preferencesKey, preferencesValue);
997    
998                            Object returnObj = null;
999    
1000                            try {
1001                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1002                            }
1003                            catch (Exception e) {
1004                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1005                            }
1006    
1007                            return (com.liferay.portal.model.LayoutReference[])returnObj;
1008                    }
1009                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1010                            _log.error(se, se);
1011    
1012                            throw se;
1013                    }
1014            }
1015    
1016            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
1017                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout) {
1018                    try {
1019                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1020                                            "getLayouts", _getLayoutsParameterTypes28);
1021    
1022                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1023                                            privateLayout);
1024    
1025                            Object returnObj = null;
1026    
1027                            try {
1028                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1029                            }
1030                            catch (Exception e) {
1031                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1032                            }
1033    
1034                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
1035                    }
1036                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1037                            _log.error(se, se);
1038    
1039                            throw se;
1040                    }
1041            }
1042    
1043            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
1044                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1045                    long parentLayoutId)
1046                    throws com.liferay.portal.kernel.exception.PortalException {
1047                    try {
1048                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1049                                            "getLayouts", _getLayoutsParameterTypes29);
1050    
1051                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1052                                            privateLayout, parentLayoutId);
1053    
1054                            Object returnObj = null;
1055    
1056                            try {
1057                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1058                            }
1059                            catch (Exception e) {
1060                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1061                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1062                                    }
1063    
1064                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1065                            }
1066    
1067                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
1068                    }
1069                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1070                            _log.error(se, se);
1071    
1072                            throw se;
1073                    }
1074            }
1075    
1076            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
1077                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1078                    long parentLayoutId, boolean incomplete, int start, int end)
1079                    throws com.liferay.portal.kernel.exception.PortalException {
1080                    try {
1081                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1082                                            "getLayouts", _getLayoutsParameterTypes30);
1083    
1084                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1085                                            privateLayout, parentLayoutId, incomplete, start, end);
1086    
1087                            Object returnObj = null;
1088    
1089                            try {
1090                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1091                            }
1092                            catch (Exception e) {
1093                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1094                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1095                                    }
1096    
1097                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1098                            }
1099    
1100                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
1101                    }
1102                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1103                            _log.error(se, se);
1104    
1105                            throw se;
1106                    }
1107            }
1108    
1109            public static int getLayoutsCount(HttpPrincipal httpPrincipal,
1110                    long groupId, boolean privateLayout, long parentLayoutId) {
1111                    try {
1112                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1113                                            "getLayoutsCount", _getLayoutsCountParameterTypes31);
1114    
1115                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1116                                            privateLayout, parentLayoutId);
1117    
1118                            Object returnObj = null;
1119    
1120                            try {
1121                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1122                            }
1123                            catch (Exception e) {
1124                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1125                            }
1126    
1127                            return ((Integer)returnObj).intValue();
1128                    }
1129                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1130                            _log.error(se, se);
1131    
1132                            throw se;
1133                    }
1134            }
1135    
1136            public static java.lang.String[] getTempFileNames(
1137                    HttpPrincipal httpPrincipal, long groupId, java.lang.String folderName)
1138                    throws com.liferay.portal.kernel.exception.PortalException {
1139                    try {
1140                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1141                                            "getTempFileNames", _getTempFileNamesParameterTypes32);
1142    
1143                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1144                                            folderName);
1145    
1146                            Object returnObj = null;
1147    
1148                            try {
1149                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1150                            }
1151                            catch (Exception e) {
1152                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1153                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1154                                    }
1155    
1156                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1157                            }
1158    
1159                            return (java.lang.String[])returnObj;
1160                    }
1161                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1162                            _log.error(se, se);
1163    
1164                            throw se;
1165                    }
1166            }
1167    
1168            public static void importLayouts(HttpPrincipal httpPrincipal,
1169                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1170                    java.io.File file)
1171                    throws com.liferay.portal.kernel.exception.PortalException {
1172                    try {
1173                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1174                                            "importLayouts", _importLayoutsParameterTypes33);
1175    
1176                            MethodHandler methodHandler = new MethodHandler(methodKey,
1177                                            exportImportConfiguration, file);
1178    
1179                            try {
1180                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1181                            }
1182                            catch (Exception e) {
1183                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1184                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1185                                    }
1186    
1187                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1188                            }
1189                    }
1190                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1191                            _log.error(se, se);
1192    
1193                            throw se;
1194                    }
1195            }
1196    
1197            public static void importLayouts(HttpPrincipal httpPrincipal,
1198                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1199                    java.io.InputStream is)
1200                    throws com.liferay.portal.kernel.exception.PortalException {
1201                    try {
1202                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1203                                            "importLayouts", _importLayoutsParameterTypes34);
1204    
1205                            MethodHandler methodHandler = new MethodHandler(methodKey,
1206                                            exportImportConfiguration, is);
1207    
1208                            try {
1209                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1210                            }
1211                            catch (Exception e) {
1212                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1213                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1214                                    }
1215    
1216                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1217                            }
1218                    }
1219                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1220                            _log.error(se, se);
1221    
1222                            throw se;
1223                    }
1224            }
1225    
1226            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1227                    boolean privateLayout,
1228                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1229                    byte[] bytes)
1230                    throws com.liferay.portal.kernel.exception.PortalException {
1231                    try {
1232                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1233                                            "importLayouts", _importLayoutsParameterTypes35);
1234    
1235                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1236                                            privateLayout, parameterMap, bytes);
1237    
1238                            try {
1239                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1240                            }
1241                            catch (Exception e) {
1242                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1243                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1244                                    }
1245    
1246                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1247                            }
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 importLayouts(HttpPrincipal httpPrincipal, long groupId,
1257                    boolean privateLayout,
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                                            "importLayouts", _importLayoutsParameterTypes36);
1264    
1265                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1266                                            privateLayout, 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 importLayouts(HttpPrincipal httpPrincipal, long groupId,
1287                    boolean privateLayout,
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                                            "importLayouts", _importLayoutsParameterTypes37);
1294    
1295                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1296                                            privateLayout, 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 long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1317                    java.lang.String taskName, long groupId, boolean privateLayout,
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                                            "importLayoutsInBackground",
1324                                            _importLayoutsInBackgroundParameterTypes38);
1325    
1326                            MethodHandler methodHandler = new MethodHandler(methodKey,
1327                                            taskName, groupId, privateLayout, parameterMap, file);
1328    
1329                            Object returnObj = null;
1330    
1331                            try {
1332                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1333                            }
1334                            catch (Exception e) {
1335                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1336                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1337                                    }
1338    
1339                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1340                            }
1341    
1342                            return ((Long)returnObj).longValue();
1343                    }
1344                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1345                            _log.error(se, se);
1346    
1347                            throw se;
1348                    }
1349            }
1350    
1351            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1352                    java.lang.String taskName, long groupId, boolean privateLayout,
1353                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1354                    java.io.InputStream inputStream)
1355                    throws com.liferay.portal.kernel.exception.PortalException {
1356                    try {
1357                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1358                                            "importLayoutsInBackground",
1359                                            _importLayoutsInBackgroundParameterTypes39);
1360    
1361                            MethodHandler methodHandler = new MethodHandler(methodKey,
1362                                            taskName, groupId, privateLayout, parameterMap, inputStream);
1363    
1364                            Object returnObj = null;
1365    
1366                            try {
1367                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1368                            }
1369                            catch (Exception e) {
1370                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1371                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1372                                    }
1373    
1374                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1375                            }
1376    
1377                            return ((Long)returnObj).longValue();
1378                    }
1379                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1380                            _log.error(se, se);
1381    
1382                            throw se;
1383                    }
1384            }
1385    
1386            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1387                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1388                    java.io.File file)
1389                    throws com.liferay.portal.kernel.exception.PortalException {
1390                    try {
1391                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1392                                            "importPortletInfo", _importPortletInfoParameterTypes40);
1393    
1394                            MethodHandler methodHandler = new MethodHandler(methodKey,
1395                                            exportImportConfiguration, file);
1396    
1397                            try {
1398                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1399                            }
1400                            catch (Exception e) {
1401                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1402                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1403                                    }
1404    
1405                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1406                            }
1407                    }
1408                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1409                            _log.error(se, se);
1410    
1411                            throw se;
1412                    }
1413            }
1414    
1415            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1416                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1417                    java.io.InputStream is)
1418                    throws com.liferay.portal.kernel.exception.PortalException {
1419                    try {
1420                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1421                                            "importPortletInfo", _importPortletInfoParameterTypes41);
1422    
1423                            MethodHandler methodHandler = new MethodHandler(methodKey,
1424                                            exportImportConfiguration, is);
1425    
1426                            try {
1427                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1428                            }
1429                            catch (Exception e) {
1430                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1431                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1432                                    }
1433    
1434                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1435                            }
1436                    }
1437                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1438                            _log.error(se, se);
1439    
1440                            throw se;
1441                    }
1442            }
1443    
1444            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1445                    long plid, long groupId, java.lang.String portletId,
1446                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1447                    java.io.File file)
1448                    throws com.liferay.portal.kernel.exception.PortalException {
1449                    try {
1450                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1451                                            "importPortletInfo", _importPortletInfoParameterTypes42);
1452    
1453                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1454                                            groupId, portletId, parameterMap, file);
1455    
1456                            try {
1457                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1458                            }
1459                            catch (Exception e) {
1460                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1461                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1462                                    }
1463    
1464                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1465                            }
1466                    }
1467                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1468                            _log.error(se, se);
1469    
1470                            throw se;
1471                    }
1472            }
1473    
1474            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1475                    long plid, long groupId, java.lang.String portletId,
1476                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1477                    java.io.InputStream is)
1478                    throws com.liferay.portal.kernel.exception.PortalException {
1479                    try {
1480                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1481                                            "importPortletInfo", _importPortletInfoParameterTypes43);
1482    
1483                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1484                                            groupId, portletId, parameterMap, is);
1485    
1486                            try {
1487                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1488                            }
1489                            catch (Exception e) {
1490                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1491                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1492                                    }
1493    
1494                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1495                            }
1496                    }
1497                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1498                            _log.error(se, se);
1499    
1500                            throw se;
1501                    }
1502            }
1503    
1504            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1505                    java.lang.String portletId,
1506                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1507                    java.io.File file)
1508                    throws com.liferay.portal.kernel.exception.PortalException {
1509                    try {
1510                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1511                                            "importPortletInfo", _importPortletInfoParameterTypes44);
1512    
1513                            MethodHandler methodHandler = new MethodHandler(methodKey,
1514                                            portletId, parameterMap, file);
1515    
1516                            try {
1517                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1518                            }
1519                            catch (Exception e) {
1520                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1521                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1522                                    }
1523    
1524                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1525                            }
1526                    }
1527                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1528                            _log.error(se, se);
1529    
1530                            throw se;
1531                    }
1532            }
1533    
1534            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1535                    java.lang.String portletId,
1536                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1537                    java.io.InputStream is)
1538                    throws com.liferay.portal.kernel.exception.PortalException {
1539                    try {
1540                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1541                                            "importPortletInfo", _importPortletInfoParameterTypes45);
1542    
1543                            MethodHandler methodHandler = new MethodHandler(methodKey,
1544                                            portletId, parameterMap, is);
1545    
1546                            try {
1547                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1548                            }
1549                            catch (Exception e) {
1550                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1551                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1552                                    }
1553    
1554                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1555                            }
1556                    }
1557                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1558                            _log.error(se, se);
1559    
1560                            throw se;
1561                    }
1562            }
1563    
1564            public static long importPortletInfoInBackground(
1565                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1566                    long groupId, java.lang.String portletId,
1567                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1568                    java.io.File file)
1569                    throws com.liferay.portal.kernel.exception.PortalException {
1570                    try {
1571                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1572                                            "importPortletInfoInBackground",
1573                                            _importPortletInfoInBackgroundParameterTypes46);
1574    
1575                            MethodHandler methodHandler = new MethodHandler(methodKey,
1576                                            taskName, plid, groupId, portletId, parameterMap, file);
1577    
1578                            Object returnObj = null;
1579    
1580                            try {
1581                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1582                            }
1583                            catch (Exception e) {
1584                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1585                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1586                                    }
1587    
1588                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1589                            }
1590    
1591                            return ((Long)returnObj).longValue();
1592                    }
1593                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1594                            _log.error(se, se);
1595    
1596                            throw se;
1597                    }
1598            }
1599    
1600            public static long importPortletInfoInBackground(
1601                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1602                    long groupId, java.lang.String portletId,
1603                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1604                    java.io.InputStream is)
1605                    throws com.liferay.portal.kernel.exception.PortalException {
1606                    try {
1607                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1608                                            "importPortletInfoInBackground",
1609                                            _importPortletInfoInBackgroundParameterTypes47);
1610    
1611                            MethodHandler methodHandler = new MethodHandler(methodKey,
1612                                            taskName, plid, groupId, portletId, parameterMap, is);
1613    
1614                            Object returnObj = null;
1615    
1616                            try {
1617                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1618                            }
1619                            catch (Exception e) {
1620                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1621                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1622                                    }
1623    
1624                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1625                            }
1626    
1627                            return ((Long)returnObj).longValue();
1628                    }
1629                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1630                            _log.error(se, se);
1631    
1632                            throw se;
1633                    }
1634            }
1635    
1636            public static void importPortletInfoInBackground(
1637                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1638                    java.lang.String portletId,
1639                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1640                    java.io.File file)
1641                    throws com.liferay.portal.kernel.exception.PortalException {
1642                    try {
1643                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1644                                            "importPortletInfoInBackground",
1645                                            _importPortletInfoInBackgroundParameterTypes48);
1646    
1647                            MethodHandler methodHandler = new MethodHandler(methodKey,
1648                                            taskName, portletId, parameterMap, file);
1649    
1650                            try {
1651                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1652                            }
1653                            catch (Exception e) {
1654                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1655                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1656                                    }
1657    
1658                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1659                            }
1660                    }
1661                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1662                            _log.error(se, se);
1663    
1664                            throw se;
1665                    }
1666            }
1667    
1668            public static void importPortletInfoInBackground(
1669                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1670                    java.lang.String portletId,
1671                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1672                    java.io.InputStream is)
1673                    throws com.liferay.portal.kernel.exception.PortalException {
1674                    try {
1675                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1676                                            "importPortletInfoInBackground",
1677                                            _importPortletInfoInBackgroundParameterTypes49);
1678    
1679                            MethodHandler methodHandler = new MethodHandler(methodKey,
1680                                            taskName, portletId, parameterMap, is);
1681    
1682                            try {
1683                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1684                            }
1685                            catch (Exception e) {
1686                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1687                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1688                                    }
1689    
1690                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1691                            }
1692                    }
1693                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1694                            _log.error(se, se);
1695    
1696                            throw se;
1697                    }
1698            }
1699    
1700            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1701                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1702                    long[] layoutIds,
1703                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1704                    java.lang.String scope, java.util.Date startDate,
1705                    java.util.Date endDate, java.lang.String groupName,
1706                    java.lang.String cronText, java.util.Date schedulerStartDate,
1707                    java.util.Date schedulerEndDate, java.lang.String description)
1708                    throws com.liferay.portal.kernel.exception.PortalException {
1709                    try {
1710                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1711                                            "schedulePublishToLive",
1712                                            _schedulePublishToLiveParameterTypes50);
1713    
1714                            MethodHandler methodHandler = new MethodHandler(methodKey,
1715                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1716                                            parameterMap, scope, startDate, endDate, groupName,
1717                                            cronText, schedulerStartDate, schedulerEndDate, description);
1718    
1719                            try {
1720                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1721                            }
1722                            catch (Exception e) {
1723                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1724                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1725                                    }
1726    
1727                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1728                            }
1729                    }
1730                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1731                            _log.error(se, se);
1732    
1733                            throw se;
1734                    }
1735            }
1736    
1737            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1738                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1739                    long[] layoutIds,
1740                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1741                    java.lang.String groupName, java.lang.String cronText,
1742                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1743                    java.lang.String description)
1744                    throws com.liferay.portal.kernel.exception.PortalException {
1745                    try {
1746                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1747                                            "schedulePublishToLive",
1748                                            _schedulePublishToLiveParameterTypes51);
1749    
1750                            MethodHandler methodHandler = new MethodHandler(methodKey,
1751                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1752                                            parameterMap, groupName, cronText, schedulerStartDate,
1753                                            schedulerEndDate, description);
1754    
1755                            try {
1756                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1757                            }
1758                            catch (Exception e) {
1759                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1760                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1761                                    }
1762    
1763                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1764                            }
1765                    }
1766                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1767                            _log.error(se, se);
1768    
1769                            throw se;
1770                    }
1771            }
1772    
1773            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1774                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1775                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1776                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1777                    java.lang.String scope, java.util.Date startDate,
1778                    java.util.Date endDate, java.lang.String groupName,
1779                    java.lang.String cronText, java.util.Date schedulerStartDate,
1780                    java.util.Date schedulerEndDate, java.lang.String description)
1781                    throws com.liferay.portal.kernel.exception.PortalException {
1782                    try {
1783                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1784                                            "schedulePublishToLive",
1785                                            _schedulePublishToLiveParameterTypes52);
1786    
1787                            MethodHandler methodHandler = new MethodHandler(methodKey,
1788                                            sourceGroupId, targetGroupId, privateLayout, layoutIdMap,
1789                                            parameterMap, scope, startDate, endDate, groupName,
1790                                            cronText, schedulerStartDate, schedulerEndDate, description);
1791    
1792                            try {
1793                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1794                            }
1795                            catch (Exception e) {
1796                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1797                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1798                                    }
1799    
1800                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1801                            }
1802                    }
1803                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1804                            _log.error(se, se);
1805    
1806                            throw se;
1807                    }
1808            }
1809    
1810            public static void schedulePublishToRemote(HttpPrincipal httpPrincipal,
1811                    long sourceGroupId, boolean privateLayout,
1812                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1813                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1814                    java.lang.String remoteAddress, int remotePort,
1815                    java.lang.String remotePathContext, boolean secureConnection,
1816                    long remoteGroupId, boolean remotePrivateLayout,
1817                    java.util.Date startDate, java.util.Date endDate,
1818                    java.lang.String groupName, java.lang.String cronText,
1819                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1820                    java.lang.String description)
1821                    throws com.liferay.portal.kernel.exception.PortalException {
1822                    try {
1823                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1824                                            "schedulePublishToRemote",
1825                                            _schedulePublishToRemoteParameterTypes53);
1826    
1827                            MethodHandler methodHandler = new MethodHandler(methodKey,
1828                                            sourceGroupId, privateLayout, layoutIdMap, parameterMap,
1829                                            remoteAddress, remotePort, remotePathContext,
1830                                            secureConnection, remoteGroupId, remotePrivateLayout,
1831                                            startDate, endDate, groupName, cronText,
1832                                            schedulerStartDate, schedulerEndDate, description);
1833    
1834                            try {
1835                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1836                            }
1837                            catch (Exception e) {
1838                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1839                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1840                                    }
1841    
1842                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1843                            }
1844                    }
1845                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1846                            _log.error(se, se);
1847    
1848                            throw se;
1849                    }
1850            }
1851    
1852            public static void setLayouts(HttpPrincipal httpPrincipal, long groupId,
1853                    boolean privateLayout, long parentLayoutId, long[] layoutIds,
1854                    com.liferay.portal.service.ServiceContext serviceContext)
1855                    throws com.liferay.portal.kernel.exception.PortalException {
1856                    try {
1857                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1858                                            "setLayouts", _setLayoutsParameterTypes54);
1859    
1860                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1861                                            privateLayout, parentLayoutId, layoutIds, serviceContext);
1862    
1863                            try {
1864                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1865                            }
1866                            catch (Exception e) {
1867                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1868                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1869                                    }
1870    
1871                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1872                            }
1873                    }
1874                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1875                            _log.error(se, se);
1876    
1877                            throw se;
1878                    }
1879            }
1880    
1881            public static void unschedulePublishToLive(HttpPrincipal httpPrincipal,
1882                    long groupId, java.lang.String jobName, java.lang.String groupName)
1883                    throws com.liferay.portal.kernel.exception.PortalException {
1884                    try {
1885                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1886                                            "unschedulePublishToLive",
1887                                            _unschedulePublishToLiveParameterTypes55);
1888    
1889                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1890                                            jobName, groupName);
1891    
1892                            try {
1893                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1894                            }
1895                            catch (Exception e) {
1896                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1897                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1898                                    }
1899    
1900                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1901                            }
1902                    }
1903                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1904                            _log.error(se, se);
1905    
1906                            throw se;
1907                    }
1908            }
1909    
1910            public static void unschedulePublishToRemote(HttpPrincipal httpPrincipal,
1911                    long groupId, java.lang.String jobName, java.lang.String groupName)
1912                    throws com.liferay.portal.kernel.exception.PortalException {
1913                    try {
1914                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1915                                            "unschedulePublishToRemote",
1916                                            _unschedulePublishToRemoteParameterTypes56);
1917    
1918                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1919                                            jobName, groupName);
1920    
1921                            try {
1922                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1923                            }
1924                            catch (Exception e) {
1925                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1926                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1927                                    }
1928    
1929                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1930                            }
1931                    }
1932                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1933                            _log.error(se, se);
1934    
1935                            throw se;
1936                    }
1937            }
1938    
1939            public static com.liferay.portal.model.Layout updateIconImage(
1940                    HttpPrincipal httpPrincipal, long plid, byte[] bytes)
1941                    throws com.liferay.portal.kernel.exception.PortalException {
1942                    try {
1943                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1944                                            "updateIconImage", _updateIconImageParameterTypes57);
1945    
1946                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1947                                            bytes);
1948    
1949                            Object returnObj = null;
1950    
1951                            try {
1952                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1953                            }
1954                            catch (Exception e) {
1955                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1956                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1957                                    }
1958    
1959                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1960                            }
1961    
1962                            return (com.liferay.portal.model.Layout)returnObj;
1963                    }
1964                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1965                            _log.error(se, se);
1966    
1967                            throw se;
1968                    }
1969            }
1970    
1971            public static com.liferay.portal.model.Layout updateLayout(
1972                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1973                    long layoutId, long parentLayoutId,
1974                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1975                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1976                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1977                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1978                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1979                    java.lang.String type, boolean hidden,
1980                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
1981                    boolean iconImage, byte[] iconBytes,
1982                    com.liferay.portal.service.ServiceContext serviceContext)
1983                    throws com.liferay.portal.kernel.exception.PortalException {
1984                    try {
1985                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1986                                            "updateLayout", _updateLayoutParameterTypes58);
1987    
1988                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1989                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1990                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1991                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
1992                                            serviceContext);
1993    
1994                            Object returnObj = null;
1995    
1996                            try {
1997                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1998                            }
1999                            catch (Exception e) {
2000                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2001                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2002                                    }
2003    
2004                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2005                            }
2006    
2007                            return (com.liferay.portal.model.Layout)returnObj;
2008                    }
2009                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2010                            _log.error(se, se);
2011    
2012                            throw se;
2013                    }
2014            }
2015    
2016            public static com.liferay.portal.model.Layout updateLayout(
2017                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2018                    long layoutId, long parentLayoutId,
2019                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
2020                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
2021                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
2022                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
2023                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
2024                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
2025                    java.lang.Boolean iconImage, byte[] iconBytes,
2026                    com.liferay.portal.service.ServiceContext serviceContext)
2027                    throws com.liferay.portal.kernel.exception.PortalException {
2028                    try {
2029                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2030                                            "updateLayout", _updateLayoutParameterTypes59);
2031    
2032                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2033                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
2034                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
2035                                            type, hidden, friendlyURL, iconImage, iconBytes,
2036                                            serviceContext);
2037    
2038                            Object returnObj = null;
2039    
2040                            try {
2041                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2042                            }
2043                            catch (Exception e) {
2044                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2045                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2046                                    }
2047    
2048                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2049                            }
2050    
2051                            return (com.liferay.portal.model.Layout)returnObj;
2052                    }
2053                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2054                            _log.error(se, se);
2055    
2056                            throw se;
2057                    }
2058            }
2059    
2060            public static com.liferay.portal.model.Layout updateLayout(
2061                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2062                    long layoutId, java.lang.String typeSettings)
2063                    throws com.liferay.portal.kernel.exception.PortalException {
2064                    try {
2065                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2066                                            "updateLayout", _updateLayoutParameterTypes60);
2067    
2068                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2069                                            privateLayout, layoutId, typeSettings);
2070    
2071                            Object returnObj = null;
2072    
2073                            try {
2074                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2075                            }
2076                            catch (Exception e) {
2077                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2078                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2079                                    }
2080    
2081                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2082                            }
2083    
2084                            return (com.liferay.portal.model.Layout)returnObj;
2085                    }
2086                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2087                            _log.error(se, se);
2088    
2089                            throw se;
2090                    }
2091            }
2092    
2093            public static com.liferay.portal.model.Layout updateLookAndFeel(
2094                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2095                    long layoutId, java.lang.String themeId,
2096                    java.lang.String colorSchemeId, java.lang.String css, boolean wapTheme)
2097                    throws com.liferay.portal.kernel.exception.PortalException {
2098                    try {
2099                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2100                                            "updateLookAndFeel", _updateLookAndFeelParameterTypes61);
2101    
2102                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2103                                            privateLayout, layoutId, themeId, colorSchemeId, css,
2104                                            wapTheme);
2105    
2106                            Object returnObj = null;
2107    
2108                            try {
2109                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2110                            }
2111                            catch (Exception e) {
2112                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2113                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2114                                    }
2115    
2116                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2117                            }
2118    
2119                            return (com.liferay.portal.model.Layout)returnObj;
2120                    }
2121                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2122                            _log.error(se, se);
2123    
2124                            throw se;
2125                    }
2126            }
2127    
2128            public static com.liferay.portal.model.Layout updateName(
2129                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2130                    long layoutId, java.lang.String name, java.lang.String languageId)
2131                    throws com.liferay.portal.kernel.exception.PortalException {
2132                    try {
2133                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2134                                            "updateName", _updateNameParameterTypes62);
2135    
2136                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2137                                            privateLayout, layoutId, name, languageId);
2138    
2139                            Object returnObj = null;
2140    
2141                            try {
2142                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2143                            }
2144                            catch (Exception e) {
2145                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2146                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2147                                    }
2148    
2149                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2150                            }
2151    
2152                            return (com.liferay.portal.model.Layout)returnObj;
2153                    }
2154                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2155                            _log.error(se, se);
2156    
2157                            throw se;
2158                    }
2159            }
2160    
2161            public static com.liferay.portal.model.Layout updateName(
2162                    HttpPrincipal httpPrincipal, long plid, java.lang.String name,
2163                    java.lang.String languageId)
2164                    throws com.liferay.portal.kernel.exception.PortalException {
2165                    try {
2166                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2167                                            "updateName", _updateNameParameterTypes63);
2168    
2169                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2170                                            name, languageId);
2171    
2172                            Object returnObj = null;
2173    
2174                            try {
2175                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2176                            }
2177                            catch (Exception e) {
2178                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2179                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2180                                    }
2181    
2182                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2183                            }
2184    
2185                            return (com.liferay.portal.model.Layout)returnObj;
2186                    }
2187                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2188                            _log.error(se, se);
2189    
2190                            throw se;
2191                    }
2192            }
2193    
2194            public static com.liferay.portal.model.Layout updateParentLayoutId(
2195                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2196                    long layoutId, long parentLayoutId)
2197                    throws com.liferay.portal.kernel.exception.PortalException {
2198                    try {
2199                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2200                                            "updateParentLayoutId",
2201                                            _updateParentLayoutIdParameterTypes64);
2202    
2203                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2204                                            privateLayout, layoutId, parentLayoutId);
2205    
2206                            Object returnObj = null;
2207    
2208                            try {
2209                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2210                            }
2211                            catch (Exception e) {
2212                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2213                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2214                                    }
2215    
2216                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2217                            }
2218    
2219                            return (com.liferay.portal.model.Layout)returnObj;
2220                    }
2221                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2222                            _log.error(se, se);
2223    
2224                            throw se;
2225                    }
2226            }
2227    
2228            public static com.liferay.portal.model.Layout updateParentLayoutId(
2229                    HttpPrincipal httpPrincipal, long plid, long parentPlid)
2230                    throws com.liferay.portal.kernel.exception.PortalException {
2231                    try {
2232                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2233                                            "updateParentLayoutId",
2234                                            _updateParentLayoutIdParameterTypes65);
2235    
2236                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2237                                            parentPlid);
2238    
2239                            Object returnObj = null;
2240    
2241                            try {
2242                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2243                            }
2244                            catch (Exception e) {
2245                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2246                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2247                                    }
2248    
2249                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2250                            }
2251    
2252                            return (com.liferay.portal.model.Layout)returnObj;
2253                    }
2254                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2255                            _log.error(se, se);
2256    
2257                            throw se;
2258                    }
2259            }
2260    
2261            public static com.liferay.portal.model.Layout updateParentLayoutIdAndPriority(
2262                    HttpPrincipal httpPrincipal, long plid, long parentPlid, int priority)
2263                    throws com.liferay.portal.kernel.exception.PortalException {
2264                    try {
2265                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2266                                            "updateParentLayoutIdAndPriority",
2267                                            _updateParentLayoutIdAndPriorityParameterTypes66);
2268    
2269                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2270                                            parentPlid, priority);
2271    
2272                            Object returnObj = null;
2273    
2274                            try {
2275                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2276                            }
2277                            catch (Exception e) {
2278                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2279                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2280                                    }
2281    
2282                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2283                            }
2284    
2285                            return (com.liferay.portal.model.Layout)returnObj;
2286                    }
2287                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2288                            _log.error(se, se);
2289    
2290                            throw se;
2291                    }
2292            }
2293    
2294            public static com.liferay.portal.model.Layout updatePriority(
2295                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2296                    long layoutId, int priority)
2297                    throws com.liferay.portal.kernel.exception.PortalException {
2298                    try {
2299                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2300                                            "updatePriority", _updatePriorityParameterTypes67);
2301    
2302                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2303                                            privateLayout, layoutId, priority);
2304    
2305                            Object returnObj = null;
2306    
2307                            try {
2308                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2309                            }
2310                            catch (Exception e) {
2311                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2312                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2313                                    }
2314    
2315                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2316                            }
2317    
2318                            return (com.liferay.portal.model.Layout)returnObj;
2319                    }
2320                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2321                            _log.error(se, se);
2322    
2323                            throw se;
2324                    }
2325            }
2326    
2327            public static com.liferay.portal.model.Layout updatePriority(
2328                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2329                    long layoutId, long nextLayoutId, long previousLayoutId)
2330                    throws com.liferay.portal.kernel.exception.PortalException {
2331                    try {
2332                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2333                                            "updatePriority", _updatePriorityParameterTypes68);
2334    
2335                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2336                                            privateLayout, layoutId, nextLayoutId, previousLayoutId);
2337    
2338                            Object returnObj = null;
2339    
2340                            try {
2341                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2342                            }
2343                            catch (Exception e) {
2344                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2345                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2346                                    }
2347    
2348                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2349                            }
2350    
2351                            return (com.liferay.portal.model.Layout)returnObj;
2352                    }
2353                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2354                            _log.error(se, se);
2355    
2356                            throw se;
2357                    }
2358            }
2359    
2360            public static com.liferay.portal.model.Layout updatePriority(
2361                    HttpPrincipal httpPrincipal, long plid, int priority)
2362                    throws com.liferay.portal.kernel.exception.PortalException {
2363                    try {
2364                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2365                                            "updatePriority", _updatePriorityParameterTypes69);
2366    
2367                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2368                                            priority);
2369    
2370                            Object returnObj = null;
2371    
2372                            try {
2373                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2374                            }
2375                            catch (Exception e) {
2376                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2377                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2378                                    }
2379    
2380                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2381                            }
2382    
2383                            return (com.liferay.portal.model.Layout)returnObj;
2384                    }
2385                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2386                            _log.error(se, se);
2387    
2388                            throw se;
2389                    }
2390            }
2391    
2392            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2393                    HttpPrincipal httpPrincipal,
2394                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2395                    java.io.File file)
2396                    throws com.liferay.portal.kernel.exception.PortalException {
2397                    try {
2398                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2399                                            "validateImportLayoutsFile",
2400                                            _validateImportLayoutsFileParameterTypes70);
2401    
2402                            MethodHandler methodHandler = new MethodHandler(methodKey,
2403                                            exportImportConfiguration, file);
2404    
2405                            Object returnObj = null;
2406    
2407                            try {
2408                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2409                            }
2410                            catch (Exception e) {
2411                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2412                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2413                                    }
2414    
2415                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2416                            }
2417    
2418                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2419                    }
2420                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2421                            _log.error(se, se);
2422    
2423                            throw se;
2424                    }
2425            }
2426    
2427            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2428                    HttpPrincipal httpPrincipal,
2429                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2430                    java.io.InputStream inputStream)
2431                    throws com.liferay.portal.kernel.exception.PortalException {
2432                    try {
2433                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2434                                            "validateImportLayoutsFile",
2435                                            _validateImportLayoutsFileParameterTypes71);
2436    
2437                            MethodHandler methodHandler = new MethodHandler(methodKey,
2438                                            exportImportConfiguration, inputStream);
2439    
2440                            Object returnObj = null;
2441    
2442                            try {
2443                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2444                            }
2445                            catch (Exception e) {
2446                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2447                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2448                                    }
2449    
2450                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2451                            }
2452    
2453                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2454                    }
2455                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2456                            _log.error(se, se);
2457    
2458                            throw se;
2459                    }
2460            }
2461    
2462            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2463                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2464                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2465                    java.io.File file)
2466                    throws com.liferay.portal.kernel.exception.PortalException {
2467                    try {
2468                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2469                                            "validateImportLayoutsFile",
2470                                            _validateImportLayoutsFileParameterTypes72);
2471    
2472                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2473                                            privateLayout, parameterMap, file);
2474    
2475                            Object returnObj = null;
2476    
2477                            try {
2478                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2479                            }
2480                            catch (Exception e) {
2481                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2482                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2483                                    }
2484    
2485                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2486                            }
2487    
2488                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2489                    }
2490                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2491                            _log.error(se, se);
2492    
2493                            throw se;
2494                    }
2495            }
2496    
2497            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2498                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2499                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2500                    java.io.InputStream inputStream)
2501                    throws com.liferay.portal.kernel.exception.PortalException {
2502                    try {
2503                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2504                                            "validateImportLayoutsFile",
2505                                            _validateImportLayoutsFileParameterTypes73);
2506    
2507                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2508                                            privateLayout, parameterMap, inputStream);
2509    
2510                            Object returnObj = null;
2511    
2512                            try {
2513                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2514                            }
2515                            catch (Exception e) {
2516                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2517                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2518                                    }
2519    
2520                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2521                            }
2522    
2523                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2524                    }
2525                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2526                            _log.error(se, se);
2527    
2528                            throw se;
2529                    }
2530            }
2531    
2532            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2533                    HttpPrincipal httpPrincipal,
2534                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2535                    java.io.File file)
2536                    throws com.liferay.portal.kernel.exception.PortalException {
2537                    try {
2538                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2539                                            "validateImportPortletInfo",
2540                                            _validateImportPortletInfoParameterTypes74);
2541    
2542                            MethodHandler methodHandler = new MethodHandler(methodKey,
2543                                            exportImportConfiguration, file);
2544    
2545                            Object returnObj = null;
2546    
2547                            try {
2548                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2549                            }
2550                            catch (Exception e) {
2551                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2552                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2553                                    }
2554    
2555                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2556                            }
2557    
2558                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2559                    }
2560                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2561                            _log.error(se, se);
2562    
2563                            throw se;
2564                    }
2565            }
2566    
2567            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2568                    HttpPrincipal httpPrincipal,
2569                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2570                    java.io.InputStream inputStream)
2571                    throws com.liferay.portal.kernel.exception.PortalException {
2572                    try {
2573                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2574                                            "validateImportPortletInfo",
2575                                            _validateImportPortletInfoParameterTypes75);
2576    
2577                            MethodHandler methodHandler = new MethodHandler(methodKey,
2578                                            exportImportConfiguration, inputStream);
2579    
2580                            Object returnObj = null;
2581    
2582                            try {
2583                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2584                            }
2585                            catch (Exception e) {
2586                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2587                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2588                                    }
2589    
2590                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2591                            }
2592    
2593                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2594                    }
2595                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2596                            _log.error(se, se);
2597    
2598                            throw se;
2599                    }
2600            }
2601    
2602            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2603                    HttpPrincipal httpPrincipal, long plid, long groupId,
2604                    java.lang.String portletId,
2605                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2606                    java.io.File file)
2607                    throws com.liferay.portal.kernel.exception.PortalException {
2608                    try {
2609                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2610                                            "validateImportPortletInfo",
2611                                            _validateImportPortletInfoParameterTypes76);
2612    
2613                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2614                                            groupId, portletId, parameterMap, file);
2615    
2616                            Object returnObj = null;
2617    
2618                            try {
2619                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2620                            }
2621                            catch (Exception e) {
2622                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2623                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2624                                    }
2625    
2626                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2627                            }
2628    
2629                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2630                    }
2631                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2632                            _log.error(se, se);
2633    
2634                            throw se;
2635                    }
2636            }
2637    
2638            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2639                    HttpPrincipal httpPrincipal, long plid, long groupId,
2640                    java.lang.String portletId,
2641                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2642                    java.io.InputStream inputStream)
2643                    throws com.liferay.portal.kernel.exception.PortalException {
2644                    try {
2645                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2646                                            "validateImportPortletInfo",
2647                                            _validateImportPortletInfoParameterTypes77);
2648    
2649                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2650                                            groupId, portletId, parameterMap, inputStream);
2651    
2652                            Object returnObj = null;
2653    
2654                            try {
2655                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2656                            }
2657                            catch (Exception e) {
2658                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2659                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2660                                    }
2661    
2662                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2663                            }
2664    
2665                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2666                    }
2667                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2668                            _log.error(se, se);
2669    
2670                            throw se;
2671                    }
2672            }
2673    
2674            private static Log _log = LogFactoryUtil.getLog(LayoutServiceHttp.class);
2675            private static final Class<?>[] _addLayoutParameterTypes0 = new Class[] {
2676                            long.class, boolean.class, long.class, java.util.Map.class,
2677                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2678                            java.util.Map.class, java.lang.String.class, boolean.class,
2679                            java.lang.String.class,
2680                            com.liferay.portal.service.ServiceContext.class
2681                    };
2682            private static final Class<?>[] _addLayoutParameterTypes1 = new Class[] {
2683                            long.class, boolean.class, long.class, java.util.Map.class,
2684                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2685                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2686                            boolean.class, java.util.Map.class,
2687                            com.liferay.portal.service.ServiceContext.class
2688                    };
2689            private static final Class<?>[] _addLayoutParameterTypes2 = new Class[] {
2690                            long.class, boolean.class, long.class, java.lang.String.class,
2691                            java.lang.String.class, java.lang.String.class,
2692                            java.lang.String.class, boolean.class, java.lang.String.class,
2693                            com.liferay.portal.service.ServiceContext.class
2694                    };
2695            private static final Class<?>[] _addTempFileEntryParameterTypes3 = new Class[] {
2696                            long.class, java.lang.String.class, java.lang.String.class,
2697                            java.io.InputStream.class, java.lang.String.class
2698                    };
2699            private static final Class<?>[] _deleteLayoutParameterTypes4 = new Class[] {
2700                            long.class, boolean.class, long.class,
2701                            com.liferay.portal.service.ServiceContext.class
2702                    };
2703            private static final Class<?>[] _deleteLayoutParameterTypes5 = new Class[] {
2704                            long.class, com.liferay.portal.service.ServiceContext.class
2705                    };
2706            private static final Class<?>[] _deleteTempFileEntryParameterTypes6 = new Class[] {
2707                            long.class, java.lang.String.class, java.lang.String.class
2708                    };
2709            private static final Class<?>[] _exportLayoutsParameterTypes7 = new Class[] {
2710                            long.class, boolean.class, long[].class, java.util.Map.class,
2711                            java.util.Date.class, java.util.Date.class
2712                    };
2713            private static final Class<?>[] _exportLayoutsParameterTypes8 = new Class[] {
2714                            long.class, boolean.class, java.util.Map.class, java.util.Date.class,
2715                            java.util.Date.class
2716                    };
2717            private static final Class<?>[] _exportLayoutsAsFileParameterTypes9 = new Class[] {
2718                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2719                    };
2720            private static final Class<?>[] _exportLayoutsAsFileParameterTypes10 = new Class[] {
2721                            long.class, boolean.class, long[].class, java.util.Map.class,
2722                            java.util.Date.class, java.util.Date.class
2723                    };
2724            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes11 =
2725                    new Class[] {
2726                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2727                    };
2728            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes12 =
2729                    new Class[] { long.class };
2730            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes13 =
2731                    new Class[] {
2732                            java.lang.String.class, long.class, boolean.class, long[].class,
2733                            java.util.Map.class, java.util.Date.class, java.util.Date.class
2734                    };
2735            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes14 =
2736                    new Class[] {
2737                            java.lang.String.class, long.class, boolean.class, long[].class,
2738                            java.util.Map.class, java.util.Date.class, java.util.Date.class,
2739                            java.lang.String.class
2740                    };
2741            private static final Class<?>[] _exportPortletInfoParameterTypes15 = new Class[] {
2742                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2743                            java.util.Date.class, java.util.Date.class
2744                    };
2745            private static final Class<?>[] _exportPortletInfoParameterTypes16 = new Class[] {
2746                            long.class, java.lang.String.class, java.util.Map.class,
2747                            java.util.Date.class, java.util.Date.class
2748                    };
2749            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes17 = new Class[] {
2750                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2751                    };
2752            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes18 = new Class[] {
2753                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2754                            java.util.Date.class, java.util.Date.class
2755                    };
2756            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes19 = new Class[] {
2757                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2758                            java.util.Date.class
2759                    };
2760            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes20 =
2761                    new Class[] {
2762                            java.lang.String.class, long.class, long.class,
2763                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2764                            java.util.Date.class, java.lang.String.class
2765                    };
2766            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes21 =
2767                    new Class[] {
2768                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2769                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2770                    };
2771            private static final Class<?>[] _getAncestorLayoutsParameterTypes22 = new Class[] {
2772                            long.class
2773                    };
2774            private static final Class<?>[] _getDefaultPlidParameterTypes23 = new Class[] {
2775                            long.class, long.class, boolean.class, java.lang.String.class
2776                    };
2777            private static final Class<?>[] _getDefaultPlidParameterTypes24 = new Class[] {
2778                            long.class, long.class, java.lang.String.class
2779                    };
2780            private static final Class<?>[] _getLayoutByUuidAndGroupIdParameterTypes25 = new Class[] {
2781                            java.lang.String.class, long.class, boolean.class
2782                    };
2783            private static final Class<?>[] _getLayoutNameParameterTypes26 = new Class[] {
2784                            long.class, boolean.class, long.class, java.lang.String.class
2785                    };
2786            private static final Class<?>[] _getLayoutReferencesParameterTypes27 = new Class[] {
2787                            long.class, java.lang.String.class, java.lang.String.class,
2788                            java.lang.String.class
2789                    };
2790            private static final Class<?>[] _getLayoutsParameterTypes28 = new Class[] {
2791                            long.class, boolean.class
2792                    };
2793            private static final Class<?>[] _getLayoutsParameterTypes29 = new Class[] {
2794                            long.class, boolean.class, long.class
2795                    };
2796            private static final Class<?>[] _getLayoutsParameterTypes30 = new Class[] {
2797                            long.class, boolean.class, long.class, boolean.class, int.class,
2798                            int.class
2799                    };
2800            private static final Class<?>[] _getLayoutsCountParameterTypes31 = new Class[] {
2801                            long.class, boolean.class, long.class
2802                    };
2803            private static final Class<?>[] _getTempFileNamesParameterTypes32 = new Class[] {
2804                            long.class, java.lang.String.class
2805                    };
2806            private static final Class<?>[] _importLayoutsParameterTypes33 = new Class[] {
2807                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2808                            java.io.File.class
2809                    };
2810            private static final Class<?>[] _importLayoutsParameterTypes34 = new Class[] {
2811                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2812                            java.io.InputStream.class
2813                    };
2814            private static final Class<?>[] _importLayoutsParameterTypes35 = new Class[] {
2815                            long.class, boolean.class, java.util.Map.class, byte[].class
2816                    };
2817            private static final Class<?>[] _importLayoutsParameterTypes36 = new Class[] {
2818                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2819                    };
2820            private static final Class<?>[] _importLayoutsParameterTypes37 = new Class[] {
2821                            long.class, boolean.class, java.util.Map.class,
2822                            java.io.InputStream.class
2823                    };
2824            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes38 = new Class[] {
2825                            java.lang.String.class, long.class, boolean.class,
2826                            java.util.Map.class, java.io.File.class
2827                    };
2828            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes39 = new Class[] {
2829                            java.lang.String.class, long.class, boolean.class,
2830                            java.util.Map.class, java.io.InputStream.class
2831                    };
2832            private static final Class<?>[] _importPortletInfoParameterTypes40 = new Class[] {
2833                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2834                            java.io.File.class
2835                    };
2836            private static final Class<?>[] _importPortletInfoParameterTypes41 = new Class[] {
2837                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2838                            java.io.InputStream.class
2839                    };
2840            private static final Class<?>[] _importPortletInfoParameterTypes42 = new Class[] {
2841                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2842                            java.io.File.class
2843                    };
2844            private static final Class<?>[] _importPortletInfoParameterTypes43 = new Class[] {
2845                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2846                            java.io.InputStream.class
2847                    };
2848            private static final Class<?>[] _importPortletInfoParameterTypes44 = new Class[] {
2849                            java.lang.String.class, java.util.Map.class, java.io.File.class
2850                    };
2851            private static final Class<?>[] _importPortletInfoParameterTypes45 = new Class[] {
2852                            java.lang.String.class, java.util.Map.class,
2853                            java.io.InputStream.class
2854                    };
2855            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes46 =
2856                    new Class[] {
2857                            java.lang.String.class, long.class, long.class,
2858                            java.lang.String.class, java.util.Map.class, java.io.File.class
2859                    };
2860            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes47 =
2861                    new Class[] {
2862                            java.lang.String.class, long.class, long.class,
2863                            java.lang.String.class, java.util.Map.class,
2864                            java.io.InputStream.class
2865                    };
2866            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes48 =
2867                    new Class[] {
2868                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2869                            java.io.File.class
2870                    };
2871            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes49 =
2872                    new Class[] {
2873                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2874                            java.io.InputStream.class
2875                    };
2876            private static final Class<?>[] _schedulePublishToLiveParameterTypes50 = new Class[] {
2877                            long.class, long.class, boolean.class, long[].class,
2878                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2879                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2880                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2881                    };
2882            private static final Class<?>[] _schedulePublishToLiveParameterTypes51 = new Class[] {
2883                            long.class, long.class, boolean.class, long[].class,
2884                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2885                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2886                    };
2887            private static final Class<?>[] _schedulePublishToLiveParameterTypes52 = new Class[] {
2888                            long.class, long.class, boolean.class, java.util.Map.class,
2889                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2890                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2891                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2892                    };
2893            private static final Class<?>[] _schedulePublishToRemoteParameterTypes53 = new Class[] {
2894                            long.class, boolean.class, java.util.Map.class, java.util.Map.class,
2895                            java.lang.String.class, int.class, java.lang.String.class,
2896                            boolean.class, long.class, boolean.class, java.util.Date.class,
2897                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2898                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2899                    };
2900            private static final Class<?>[] _setLayoutsParameterTypes54 = new Class[] {
2901                            long.class, boolean.class, long.class, long[].class,
2902                            com.liferay.portal.service.ServiceContext.class
2903                    };
2904            private static final Class<?>[] _unschedulePublishToLiveParameterTypes55 = new Class[] {
2905                            long.class, java.lang.String.class, java.lang.String.class
2906                    };
2907            private static final Class<?>[] _unschedulePublishToRemoteParameterTypes56 = new Class[] {
2908                            long.class, java.lang.String.class, java.lang.String.class
2909                    };
2910            private static final Class<?>[] _updateIconImageParameterTypes57 = new Class[] {
2911                            long.class, byte[].class
2912                    };
2913            private static final Class<?>[] _updateLayoutParameterTypes58 = new Class[] {
2914                            long.class, boolean.class, long.class, long.class,
2915                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2916                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2917                            boolean.class, java.util.Map.class, boolean.class, byte[].class,
2918                            com.liferay.portal.service.ServiceContext.class
2919                    };
2920            private static final Class<?>[] _updateLayoutParameterTypes59 = new Class[] {
2921                            long.class, boolean.class, long.class, long.class,
2922                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2923                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2924                            boolean.class, java.lang.String.class, java.lang.Boolean.class,
2925                            byte[].class, com.liferay.portal.service.ServiceContext.class
2926                    };
2927            private static final Class<?>[] _updateLayoutParameterTypes60 = new Class[] {
2928                            long.class, boolean.class, long.class, java.lang.String.class
2929                    };
2930            private static final Class<?>[] _updateLookAndFeelParameterTypes61 = new Class[] {
2931                            long.class, boolean.class, long.class, java.lang.String.class,
2932                            java.lang.String.class, java.lang.String.class, boolean.class
2933                    };
2934            private static final Class<?>[] _updateNameParameterTypes62 = new Class[] {
2935                            long.class, boolean.class, long.class, java.lang.String.class,
2936                            java.lang.String.class
2937                    };
2938            private static final Class<?>[] _updateNameParameterTypes63 = new Class[] {
2939                            long.class, java.lang.String.class, java.lang.String.class
2940                    };
2941            private static final Class<?>[] _updateParentLayoutIdParameterTypes64 = new Class[] {
2942                            long.class, boolean.class, long.class, long.class
2943                    };
2944            private static final Class<?>[] _updateParentLayoutIdParameterTypes65 = new Class[] {
2945                            long.class, long.class
2946                    };
2947            private static final Class<?>[] _updateParentLayoutIdAndPriorityParameterTypes66 =
2948                    new Class[] { long.class, long.class, int.class };
2949            private static final Class<?>[] _updatePriorityParameterTypes67 = new Class[] {
2950                            long.class, boolean.class, long.class, int.class
2951                    };
2952            private static final Class<?>[] _updatePriorityParameterTypes68 = new Class[] {
2953                            long.class, boolean.class, long.class, long.class, long.class
2954                    };
2955            private static final Class<?>[] _updatePriorityParameterTypes69 = new Class[] {
2956                            long.class, int.class
2957                    };
2958            private static final Class<?>[] _validateImportLayoutsFileParameterTypes70 = new Class[] {
2959                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2960                            java.io.File.class
2961                    };
2962            private static final Class<?>[] _validateImportLayoutsFileParameterTypes71 = new Class[] {
2963                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2964                            java.io.InputStream.class
2965                    };
2966            private static final Class<?>[] _validateImportLayoutsFileParameterTypes72 = new Class[] {
2967                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2968                    };
2969            private static final Class<?>[] _validateImportLayoutsFileParameterTypes73 = new Class[] {
2970                            long.class, boolean.class, java.util.Map.class,
2971                            java.io.InputStream.class
2972                    };
2973            private static final Class<?>[] _validateImportPortletInfoParameterTypes74 = new Class[] {
2974                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2975                            java.io.File.class
2976                    };
2977            private static final Class<?>[] _validateImportPortletInfoParameterTypes75 = new Class[] {
2978                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2979                            java.io.InputStream.class
2980                    };
2981            private static final Class<?>[] _validateImportPortletInfoParameterTypes76 = new Class[] {
2982                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2983                            java.io.File.class
2984                    };
2985            private static final Class<?>[] _validateImportPortletInfoParameterTypes77 = new Class[] {
2986                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2987                            java.io.InputStream.class
2988                    };
2989    }