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                    try {
1047                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1048                                            "getLayouts", _getLayoutsParameterTypes29);
1049    
1050                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1051                                            privateLayout, parentLayoutId);
1052    
1053                            Object returnObj = null;
1054    
1055                            try {
1056                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1057                            }
1058                            catch (Exception e) {
1059                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1060                            }
1061    
1062                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
1063                    }
1064                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1065                            _log.error(se, se);
1066    
1067                            throw se;
1068                    }
1069            }
1070    
1071            public static java.util.List<com.liferay.portal.model.Layout> getLayouts(
1072                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1073                    long parentLayoutId, boolean incomplete, int start, int end)
1074                    throws com.liferay.portal.kernel.exception.PortalException {
1075                    try {
1076                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1077                                            "getLayouts", _getLayoutsParameterTypes30);
1078    
1079                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1080                                            privateLayout, parentLayoutId, incomplete, start, end);
1081    
1082                            Object returnObj = null;
1083    
1084                            try {
1085                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1086                            }
1087                            catch (Exception e) {
1088                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1089                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1090                                    }
1091    
1092                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1093                            }
1094    
1095                            return (java.util.List<com.liferay.portal.model.Layout>)returnObj;
1096                    }
1097                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1098                            _log.error(se, se);
1099    
1100                            throw se;
1101                    }
1102            }
1103    
1104            public static int getLayoutsCount(HttpPrincipal httpPrincipal,
1105                    long groupId, boolean privateLayout, long parentLayoutId) {
1106                    try {
1107                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1108                                            "getLayoutsCount", _getLayoutsCountParameterTypes31);
1109    
1110                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1111                                            privateLayout, parentLayoutId);
1112    
1113                            Object returnObj = null;
1114    
1115                            try {
1116                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1117                            }
1118                            catch (Exception e) {
1119                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1120                            }
1121    
1122                            return ((Integer)returnObj).intValue();
1123                    }
1124                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1125                            _log.error(se, se);
1126    
1127                            throw se;
1128                    }
1129            }
1130    
1131            public static java.lang.String[] getTempFileNames(
1132                    HttpPrincipal httpPrincipal, long groupId, java.lang.String folderName)
1133                    throws com.liferay.portal.kernel.exception.PortalException {
1134                    try {
1135                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1136                                            "getTempFileNames", _getTempFileNamesParameterTypes32);
1137    
1138                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1139                                            folderName);
1140    
1141                            Object returnObj = null;
1142    
1143                            try {
1144                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1145                            }
1146                            catch (Exception e) {
1147                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1148                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1149                                    }
1150    
1151                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1152                            }
1153    
1154                            return (java.lang.String[])returnObj;
1155                    }
1156                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1157                            _log.error(se, se);
1158    
1159                            throw se;
1160                    }
1161            }
1162    
1163            public static void importLayouts(HttpPrincipal httpPrincipal,
1164                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1165                    java.io.File file)
1166                    throws com.liferay.portal.kernel.exception.PortalException {
1167                    try {
1168                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1169                                            "importLayouts", _importLayoutsParameterTypes33);
1170    
1171                            MethodHandler methodHandler = new MethodHandler(methodKey,
1172                                            exportImportConfiguration, file);
1173    
1174                            try {
1175                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1176                            }
1177                            catch (Exception e) {
1178                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1179                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1180                                    }
1181    
1182                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1183                            }
1184                    }
1185                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1186                            _log.error(se, se);
1187    
1188                            throw se;
1189                    }
1190            }
1191    
1192            public static void importLayouts(HttpPrincipal httpPrincipal,
1193                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1194                    java.io.InputStream is)
1195                    throws com.liferay.portal.kernel.exception.PortalException {
1196                    try {
1197                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1198                                            "importLayouts", _importLayoutsParameterTypes34);
1199    
1200                            MethodHandler methodHandler = new MethodHandler(methodKey,
1201                                            exportImportConfiguration, is);
1202    
1203                            try {
1204                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1205                            }
1206                            catch (Exception e) {
1207                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1208                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1209                                    }
1210    
1211                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1212                            }
1213                    }
1214                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1215                            _log.error(se, se);
1216    
1217                            throw se;
1218                    }
1219            }
1220    
1221            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1222                    boolean privateLayout,
1223                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1224                    byte[] bytes)
1225                    throws com.liferay.portal.kernel.exception.PortalException {
1226                    try {
1227                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1228                                            "importLayouts", _importLayoutsParameterTypes35);
1229    
1230                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1231                                            privateLayout, parameterMap, bytes);
1232    
1233                            try {
1234                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1235                            }
1236                            catch (Exception e) {
1237                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1238                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1239                                    }
1240    
1241                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1242                            }
1243                    }
1244                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1245                            _log.error(se, se);
1246    
1247                            throw se;
1248                    }
1249            }
1250    
1251            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1252                    boolean privateLayout,
1253                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1254                    java.io.File file)
1255                    throws com.liferay.portal.kernel.exception.PortalException {
1256                    try {
1257                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1258                                            "importLayouts", _importLayoutsParameterTypes36);
1259    
1260                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1261                                            privateLayout, parameterMap, file);
1262    
1263                            try {
1264                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1265                            }
1266                            catch (Exception e) {
1267                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1268                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1269                                    }
1270    
1271                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1272                            }
1273                    }
1274                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1275                            _log.error(se, se);
1276    
1277                            throw se;
1278                    }
1279            }
1280    
1281            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1282                    boolean privateLayout,
1283                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1284                    java.io.InputStream is)
1285                    throws com.liferay.portal.kernel.exception.PortalException {
1286                    try {
1287                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1288                                            "importLayouts", _importLayoutsParameterTypes37);
1289    
1290                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1291                                            privateLayout, parameterMap, is);
1292    
1293                            try {
1294                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1295                            }
1296                            catch (Exception e) {
1297                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1298                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1299                                    }
1300    
1301                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1302                            }
1303                    }
1304                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1305                            _log.error(se, se);
1306    
1307                            throw se;
1308                    }
1309            }
1310    
1311            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1312                    java.lang.String taskName, long groupId, boolean privateLayout,
1313                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1314                    java.io.File file)
1315                    throws com.liferay.portal.kernel.exception.PortalException {
1316                    try {
1317                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1318                                            "importLayoutsInBackground",
1319                                            _importLayoutsInBackgroundParameterTypes38);
1320    
1321                            MethodHandler methodHandler = new MethodHandler(methodKey,
1322                                            taskName, groupId, privateLayout, parameterMap, file);
1323    
1324                            Object returnObj = null;
1325    
1326                            try {
1327                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1328                            }
1329                            catch (Exception e) {
1330                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1331                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1332                                    }
1333    
1334                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1335                            }
1336    
1337                            return ((Long)returnObj).longValue();
1338                    }
1339                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1340                            _log.error(se, se);
1341    
1342                            throw se;
1343                    }
1344            }
1345    
1346            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1347                    java.lang.String taskName, long groupId, boolean privateLayout,
1348                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1349                    java.io.InputStream inputStream)
1350                    throws com.liferay.portal.kernel.exception.PortalException {
1351                    try {
1352                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1353                                            "importLayoutsInBackground",
1354                                            _importLayoutsInBackgroundParameterTypes39);
1355    
1356                            MethodHandler methodHandler = new MethodHandler(methodKey,
1357                                            taskName, groupId, privateLayout, parameterMap, inputStream);
1358    
1359                            Object returnObj = null;
1360    
1361                            try {
1362                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1363                            }
1364                            catch (Exception e) {
1365                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1366                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1367                                    }
1368    
1369                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1370                            }
1371    
1372                            return ((Long)returnObj).longValue();
1373                    }
1374                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1375                            _log.error(se, se);
1376    
1377                            throw se;
1378                    }
1379            }
1380    
1381            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1382                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1383                    java.io.File file)
1384                    throws com.liferay.portal.kernel.exception.PortalException {
1385                    try {
1386                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1387                                            "importPortletInfo", _importPortletInfoParameterTypes40);
1388    
1389                            MethodHandler methodHandler = new MethodHandler(methodKey,
1390                                            exportImportConfiguration, file);
1391    
1392                            try {
1393                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1394                            }
1395                            catch (Exception e) {
1396                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1397                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1398                                    }
1399    
1400                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1401                            }
1402                    }
1403                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1404                            _log.error(se, se);
1405    
1406                            throw se;
1407                    }
1408            }
1409    
1410            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1411                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
1412                    java.io.InputStream is)
1413                    throws com.liferay.portal.kernel.exception.PortalException {
1414                    try {
1415                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1416                                            "importPortletInfo", _importPortletInfoParameterTypes41);
1417    
1418                            MethodHandler methodHandler = new MethodHandler(methodKey,
1419                                            exportImportConfiguration, is);
1420    
1421                            try {
1422                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1423                            }
1424                            catch (Exception e) {
1425                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1426                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1427                                    }
1428    
1429                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1430                            }
1431                    }
1432                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1433                            _log.error(se, se);
1434    
1435                            throw se;
1436                    }
1437            }
1438    
1439            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1440                    long plid, long groupId, java.lang.String portletId,
1441                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1442                    java.io.File file)
1443                    throws com.liferay.portal.kernel.exception.PortalException {
1444                    try {
1445                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1446                                            "importPortletInfo", _importPortletInfoParameterTypes42);
1447    
1448                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1449                                            groupId, portletId, parameterMap, file);
1450    
1451                            try {
1452                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1453                            }
1454                            catch (Exception e) {
1455                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1456                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1457                                    }
1458    
1459                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1460                            }
1461                    }
1462                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1463                            _log.error(se, se);
1464    
1465                            throw se;
1466                    }
1467            }
1468    
1469            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1470                    long plid, long groupId, java.lang.String portletId,
1471                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1472                    java.io.InputStream is)
1473                    throws com.liferay.portal.kernel.exception.PortalException {
1474                    try {
1475                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1476                                            "importPortletInfo", _importPortletInfoParameterTypes43);
1477    
1478                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1479                                            groupId, portletId, parameterMap, is);
1480    
1481                            try {
1482                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1483                            }
1484                            catch (Exception e) {
1485                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1486                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1487                                    }
1488    
1489                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1490                            }
1491                    }
1492                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1493                            _log.error(se, se);
1494    
1495                            throw se;
1496                    }
1497            }
1498    
1499            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1500                    java.lang.String portletId,
1501                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1502                    java.io.File file)
1503                    throws com.liferay.portal.kernel.exception.PortalException {
1504                    try {
1505                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1506                                            "importPortletInfo", _importPortletInfoParameterTypes44);
1507    
1508                            MethodHandler methodHandler = new MethodHandler(methodKey,
1509                                            portletId, parameterMap, file);
1510    
1511                            try {
1512                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1513                            }
1514                            catch (Exception e) {
1515                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1516                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1517                                    }
1518    
1519                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1520                            }
1521                    }
1522                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1523                            _log.error(se, se);
1524    
1525                            throw se;
1526                    }
1527            }
1528    
1529            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1530                    java.lang.String portletId,
1531                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1532                    java.io.InputStream is)
1533                    throws com.liferay.portal.kernel.exception.PortalException {
1534                    try {
1535                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1536                                            "importPortletInfo", _importPortletInfoParameterTypes45);
1537    
1538                            MethodHandler methodHandler = new MethodHandler(methodKey,
1539                                            portletId, parameterMap, is);
1540    
1541                            try {
1542                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1543                            }
1544                            catch (Exception e) {
1545                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1546                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1547                                    }
1548    
1549                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1550                            }
1551                    }
1552                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1553                            _log.error(se, se);
1554    
1555                            throw se;
1556                    }
1557            }
1558    
1559            public static long importPortletInfoInBackground(
1560                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1561                    long groupId, java.lang.String portletId,
1562                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1563                    java.io.File file)
1564                    throws com.liferay.portal.kernel.exception.PortalException {
1565                    try {
1566                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1567                                            "importPortletInfoInBackground",
1568                                            _importPortletInfoInBackgroundParameterTypes46);
1569    
1570                            MethodHandler methodHandler = new MethodHandler(methodKey,
1571                                            taskName, plid, groupId, portletId, parameterMap, file);
1572    
1573                            Object returnObj = null;
1574    
1575                            try {
1576                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1577                            }
1578                            catch (Exception e) {
1579                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1580                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1581                                    }
1582    
1583                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1584                            }
1585    
1586                            return ((Long)returnObj).longValue();
1587                    }
1588                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1589                            _log.error(se, se);
1590    
1591                            throw se;
1592                    }
1593            }
1594    
1595            public static long importPortletInfoInBackground(
1596                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1597                    long groupId, java.lang.String portletId,
1598                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1599                    java.io.InputStream is)
1600                    throws com.liferay.portal.kernel.exception.PortalException {
1601                    try {
1602                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1603                                            "importPortletInfoInBackground",
1604                                            _importPortletInfoInBackgroundParameterTypes47);
1605    
1606                            MethodHandler methodHandler = new MethodHandler(methodKey,
1607                                            taskName, plid, groupId, portletId, parameterMap, is);
1608    
1609                            Object returnObj = null;
1610    
1611                            try {
1612                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1613                            }
1614                            catch (Exception e) {
1615                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1616                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1617                                    }
1618    
1619                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1620                            }
1621    
1622                            return ((Long)returnObj).longValue();
1623                    }
1624                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1625                            _log.error(se, se);
1626    
1627                            throw se;
1628                    }
1629            }
1630    
1631            public static void importPortletInfoInBackground(
1632                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1633                    java.lang.String portletId,
1634                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1635                    java.io.File file)
1636                    throws com.liferay.portal.kernel.exception.PortalException {
1637                    try {
1638                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1639                                            "importPortletInfoInBackground",
1640                                            _importPortletInfoInBackgroundParameterTypes48);
1641    
1642                            MethodHandler methodHandler = new MethodHandler(methodKey,
1643                                            taskName, portletId, parameterMap, file);
1644    
1645                            try {
1646                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1647                            }
1648                            catch (Exception e) {
1649                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1650                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1651                                    }
1652    
1653                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1654                            }
1655                    }
1656                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1657                            _log.error(se, se);
1658    
1659                            throw se;
1660                    }
1661            }
1662    
1663            public static void importPortletInfoInBackground(
1664                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1665                    java.lang.String portletId,
1666                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1667                    java.io.InputStream is)
1668                    throws com.liferay.portal.kernel.exception.PortalException {
1669                    try {
1670                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1671                                            "importPortletInfoInBackground",
1672                                            _importPortletInfoInBackgroundParameterTypes49);
1673    
1674                            MethodHandler methodHandler = new MethodHandler(methodKey,
1675                                            taskName, portletId, parameterMap, is);
1676    
1677                            try {
1678                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1679                            }
1680                            catch (Exception e) {
1681                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1682                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1683                                    }
1684    
1685                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1686                            }
1687                    }
1688                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1689                            _log.error(se, se);
1690    
1691                            throw se;
1692                    }
1693            }
1694    
1695            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1696                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1697                    long[] layoutIds,
1698                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1699                    java.lang.String scope, java.util.Date startDate,
1700                    java.util.Date endDate, java.lang.String groupName,
1701                    java.lang.String cronText, java.util.Date schedulerStartDate,
1702                    java.util.Date schedulerEndDate, java.lang.String description)
1703                    throws com.liferay.portal.kernel.exception.PortalException {
1704                    try {
1705                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1706                                            "schedulePublishToLive",
1707                                            _schedulePublishToLiveParameterTypes50);
1708    
1709                            MethodHandler methodHandler = new MethodHandler(methodKey,
1710                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1711                                            parameterMap, scope, startDate, endDate, groupName,
1712                                            cronText, schedulerStartDate, schedulerEndDate, description);
1713    
1714                            try {
1715                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1716                            }
1717                            catch (Exception e) {
1718                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1719                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1720                                    }
1721    
1722                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1723                            }
1724                    }
1725                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1726                            _log.error(se, se);
1727    
1728                            throw se;
1729                    }
1730            }
1731    
1732            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1733                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1734                    long[] layoutIds,
1735                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1736                    java.lang.String groupName, java.lang.String cronText,
1737                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1738                    java.lang.String description)
1739                    throws com.liferay.portal.kernel.exception.PortalException {
1740                    try {
1741                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1742                                            "schedulePublishToLive",
1743                                            _schedulePublishToLiveParameterTypes51);
1744    
1745                            MethodHandler methodHandler = new MethodHandler(methodKey,
1746                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1747                                            parameterMap, groupName, cronText, schedulerStartDate,
1748                                            schedulerEndDate, description);
1749    
1750                            try {
1751                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1752                            }
1753                            catch (Exception e) {
1754                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1755                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1756                                    }
1757    
1758                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1759                            }
1760                    }
1761                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1762                            _log.error(se, se);
1763    
1764                            throw se;
1765                    }
1766            }
1767    
1768            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1769                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1770                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1771                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1772                    java.lang.String scope, java.util.Date startDate,
1773                    java.util.Date endDate, java.lang.String groupName,
1774                    java.lang.String cronText, java.util.Date schedulerStartDate,
1775                    java.util.Date schedulerEndDate, java.lang.String description)
1776                    throws com.liferay.portal.kernel.exception.PortalException {
1777                    try {
1778                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1779                                            "schedulePublishToLive",
1780                                            _schedulePublishToLiveParameterTypes52);
1781    
1782                            MethodHandler methodHandler = new MethodHandler(methodKey,
1783                                            sourceGroupId, targetGroupId, privateLayout, layoutIdMap,
1784                                            parameterMap, scope, startDate, endDate, groupName,
1785                                            cronText, schedulerStartDate, schedulerEndDate, description);
1786    
1787                            try {
1788                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1789                            }
1790                            catch (Exception e) {
1791                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1792                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1793                                    }
1794    
1795                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1796                            }
1797                    }
1798                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1799                            _log.error(se, se);
1800    
1801                            throw se;
1802                    }
1803            }
1804    
1805            public static void schedulePublishToRemote(HttpPrincipal httpPrincipal,
1806                    long sourceGroupId, boolean privateLayout,
1807                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1808                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1809                    java.lang.String remoteAddress, int remotePort,
1810                    java.lang.String remotePathContext, boolean secureConnection,
1811                    long remoteGroupId, boolean remotePrivateLayout,
1812                    java.util.Date startDate, java.util.Date endDate,
1813                    java.lang.String groupName, java.lang.String cronText,
1814                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1815                    java.lang.String description)
1816                    throws com.liferay.portal.kernel.exception.PortalException {
1817                    try {
1818                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1819                                            "schedulePublishToRemote",
1820                                            _schedulePublishToRemoteParameterTypes53);
1821    
1822                            MethodHandler methodHandler = new MethodHandler(methodKey,
1823                                            sourceGroupId, privateLayout, layoutIdMap, parameterMap,
1824                                            remoteAddress, remotePort, remotePathContext,
1825                                            secureConnection, remoteGroupId, remotePrivateLayout,
1826                                            startDate, endDate, groupName, cronText,
1827                                            schedulerStartDate, schedulerEndDate, description);
1828    
1829                            try {
1830                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1831                            }
1832                            catch (Exception e) {
1833                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1834                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1835                                    }
1836    
1837                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1838                            }
1839                    }
1840                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1841                            _log.error(se, se);
1842    
1843                            throw se;
1844                    }
1845            }
1846    
1847            public static void setLayouts(HttpPrincipal httpPrincipal, long groupId,
1848                    boolean privateLayout, long parentLayoutId, long[] layoutIds,
1849                    com.liferay.portal.service.ServiceContext serviceContext)
1850                    throws com.liferay.portal.kernel.exception.PortalException {
1851                    try {
1852                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1853                                            "setLayouts", _setLayoutsParameterTypes54);
1854    
1855                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1856                                            privateLayout, parentLayoutId, layoutIds, serviceContext);
1857    
1858                            try {
1859                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1860                            }
1861                            catch (Exception e) {
1862                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1863                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1864                                    }
1865    
1866                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1867                            }
1868                    }
1869                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1870                            _log.error(se, se);
1871    
1872                            throw se;
1873                    }
1874            }
1875    
1876            public static void unschedulePublishToLive(HttpPrincipal httpPrincipal,
1877                    long groupId, java.lang.String jobName, java.lang.String groupName)
1878                    throws com.liferay.portal.kernel.exception.PortalException {
1879                    try {
1880                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1881                                            "unschedulePublishToLive",
1882                                            _unschedulePublishToLiveParameterTypes55);
1883    
1884                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1885                                            jobName, groupName);
1886    
1887                            try {
1888                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1889                            }
1890                            catch (Exception e) {
1891                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1892                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1893                                    }
1894    
1895                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1896                            }
1897                    }
1898                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1899                            _log.error(se, se);
1900    
1901                            throw se;
1902                    }
1903            }
1904    
1905            public static void unschedulePublishToRemote(HttpPrincipal httpPrincipal,
1906                    long groupId, java.lang.String jobName, java.lang.String groupName)
1907                    throws com.liferay.portal.kernel.exception.PortalException {
1908                    try {
1909                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1910                                            "unschedulePublishToRemote",
1911                                            _unschedulePublishToRemoteParameterTypes56);
1912    
1913                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1914                                            jobName, groupName);
1915    
1916                            try {
1917                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1918                            }
1919                            catch (Exception e) {
1920                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1921                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1922                                    }
1923    
1924                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1925                            }
1926                    }
1927                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1928                            _log.error(se, se);
1929    
1930                            throw se;
1931                    }
1932            }
1933    
1934            public static com.liferay.portal.model.Layout updateIconImage(
1935                    HttpPrincipal httpPrincipal, long plid, byte[] bytes)
1936                    throws com.liferay.portal.kernel.exception.PortalException {
1937                    try {
1938                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1939                                            "updateIconImage", _updateIconImageParameterTypes57);
1940    
1941                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1942                                            bytes);
1943    
1944                            Object returnObj = null;
1945    
1946                            try {
1947                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1948                            }
1949                            catch (Exception e) {
1950                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1951                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1952                                    }
1953    
1954                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1955                            }
1956    
1957                            return (com.liferay.portal.model.Layout)returnObj;
1958                    }
1959                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1960                            _log.error(se, se);
1961    
1962                            throw se;
1963                    }
1964            }
1965    
1966            public static com.liferay.portal.model.Layout updateLayout(
1967                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1968                    long layoutId, long parentLayoutId,
1969                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1970                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1971                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1972                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1973                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1974                    java.lang.String type, boolean hidden,
1975                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
1976                    boolean iconImage, byte[] iconBytes,
1977                    com.liferay.portal.service.ServiceContext serviceContext)
1978                    throws com.liferay.portal.kernel.exception.PortalException {
1979                    try {
1980                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1981                                            "updateLayout", _updateLayoutParameterTypes58);
1982    
1983                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1984                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1985                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1986                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
1987                                            serviceContext);
1988    
1989                            Object returnObj = null;
1990    
1991                            try {
1992                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1993                            }
1994                            catch (Exception e) {
1995                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1996                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1997                                    }
1998    
1999                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2000                            }
2001    
2002                            return (com.liferay.portal.model.Layout)returnObj;
2003                    }
2004                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2005                            _log.error(se, se);
2006    
2007                            throw se;
2008                    }
2009            }
2010    
2011            public static com.liferay.portal.model.Layout updateLayout(
2012                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2013                    long layoutId, long parentLayoutId,
2014                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
2015                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
2016                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
2017                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
2018                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
2019                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
2020                    java.lang.Boolean iconImage, byte[] iconBytes,
2021                    com.liferay.portal.service.ServiceContext serviceContext)
2022                    throws com.liferay.portal.kernel.exception.PortalException {
2023                    try {
2024                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2025                                            "updateLayout", _updateLayoutParameterTypes59);
2026    
2027                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2028                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
2029                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
2030                                            type, hidden, friendlyURL, iconImage, iconBytes,
2031                                            serviceContext);
2032    
2033                            Object returnObj = null;
2034    
2035                            try {
2036                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2037                            }
2038                            catch (Exception e) {
2039                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2040                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2041                                    }
2042    
2043                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2044                            }
2045    
2046                            return (com.liferay.portal.model.Layout)returnObj;
2047                    }
2048                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2049                            _log.error(se, se);
2050    
2051                            throw se;
2052                    }
2053            }
2054    
2055            public static com.liferay.portal.model.Layout updateLayout(
2056                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2057                    long layoutId, java.lang.String typeSettings)
2058                    throws com.liferay.portal.kernel.exception.PortalException {
2059                    try {
2060                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2061                                            "updateLayout", _updateLayoutParameterTypes60);
2062    
2063                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2064                                            privateLayout, layoutId, typeSettings);
2065    
2066                            Object returnObj = null;
2067    
2068                            try {
2069                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2070                            }
2071                            catch (Exception e) {
2072                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2073                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2074                                    }
2075    
2076                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2077                            }
2078    
2079                            return (com.liferay.portal.model.Layout)returnObj;
2080                    }
2081                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2082                            _log.error(se, se);
2083    
2084                            throw se;
2085                    }
2086            }
2087    
2088            public static com.liferay.portal.model.Layout updateLookAndFeel(
2089                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2090                    long layoutId, java.lang.String themeId,
2091                    java.lang.String colorSchemeId, java.lang.String css, boolean wapTheme)
2092                    throws com.liferay.portal.kernel.exception.PortalException {
2093                    try {
2094                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2095                                            "updateLookAndFeel", _updateLookAndFeelParameterTypes61);
2096    
2097                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2098                                            privateLayout, layoutId, themeId, colorSchemeId, css,
2099                                            wapTheme);
2100    
2101                            Object returnObj = null;
2102    
2103                            try {
2104                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2105                            }
2106                            catch (Exception e) {
2107                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2108                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2109                                    }
2110    
2111                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2112                            }
2113    
2114                            return (com.liferay.portal.model.Layout)returnObj;
2115                    }
2116                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2117                            _log.error(se, se);
2118    
2119                            throw se;
2120                    }
2121            }
2122    
2123            public static com.liferay.portal.model.Layout updateName(
2124                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2125                    long layoutId, java.lang.String name, java.lang.String languageId)
2126                    throws com.liferay.portal.kernel.exception.PortalException {
2127                    try {
2128                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2129                                            "updateName", _updateNameParameterTypes62);
2130    
2131                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2132                                            privateLayout, layoutId, name, languageId);
2133    
2134                            Object returnObj = null;
2135    
2136                            try {
2137                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2138                            }
2139                            catch (Exception e) {
2140                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2141                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2142                                    }
2143    
2144                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2145                            }
2146    
2147                            return (com.liferay.portal.model.Layout)returnObj;
2148                    }
2149                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2150                            _log.error(se, se);
2151    
2152                            throw se;
2153                    }
2154            }
2155    
2156            public static com.liferay.portal.model.Layout updateName(
2157                    HttpPrincipal httpPrincipal, long plid, java.lang.String name,
2158                    java.lang.String languageId)
2159                    throws com.liferay.portal.kernel.exception.PortalException {
2160                    try {
2161                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2162                                            "updateName", _updateNameParameterTypes63);
2163    
2164                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2165                                            name, languageId);
2166    
2167                            Object returnObj = null;
2168    
2169                            try {
2170                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2171                            }
2172                            catch (Exception e) {
2173                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2174                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2175                                    }
2176    
2177                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2178                            }
2179    
2180                            return (com.liferay.portal.model.Layout)returnObj;
2181                    }
2182                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2183                            _log.error(se, se);
2184    
2185                            throw se;
2186                    }
2187            }
2188    
2189            public static com.liferay.portal.model.Layout updateParentLayoutId(
2190                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2191                    long layoutId, long parentLayoutId)
2192                    throws com.liferay.portal.kernel.exception.PortalException {
2193                    try {
2194                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2195                                            "updateParentLayoutId",
2196                                            _updateParentLayoutIdParameterTypes64);
2197    
2198                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2199                                            privateLayout, layoutId, parentLayoutId);
2200    
2201                            Object returnObj = null;
2202    
2203                            try {
2204                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2205                            }
2206                            catch (Exception e) {
2207                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2208                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2209                                    }
2210    
2211                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2212                            }
2213    
2214                            return (com.liferay.portal.model.Layout)returnObj;
2215                    }
2216                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2217                            _log.error(se, se);
2218    
2219                            throw se;
2220                    }
2221            }
2222    
2223            public static com.liferay.portal.model.Layout updateParentLayoutId(
2224                    HttpPrincipal httpPrincipal, long plid, long parentPlid)
2225                    throws com.liferay.portal.kernel.exception.PortalException {
2226                    try {
2227                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2228                                            "updateParentLayoutId",
2229                                            _updateParentLayoutIdParameterTypes65);
2230    
2231                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2232                                            parentPlid);
2233    
2234                            Object returnObj = null;
2235    
2236                            try {
2237                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2238                            }
2239                            catch (Exception e) {
2240                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2241                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2242                                    }
2243    
2244                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2245                            }
2246    
2247                            return (com.liferay.portal.model.Layout)returnObj;
2248                    }
2249                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2250                            _log.error(se, se);
2251    
2252                            throw se;
2253                    }
2254            }
2255    
2256            public static com.liferay.portal.model.Layout updateParentLayoutIdAndPriority(
2257                    HttpPrincipal httpPrincipal, long plid, long parentPlid, int priority)
2258                    throws com.liferay.portal.kernel.exception.PortalException {
2259                    try {
2260                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2261                                            "updateParentLayoutIdAndPriority",
2262                                            _updateParentLayoutIdAndPriorityParameterTypes66);
2263    
2264                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2265                                            parentPlid, priority);
2266    
2267                            Object returnObj = null;
2268    
2269                            try {
2270                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2271                            }
2272                            catch (Exception e) {
2273                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2274                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2275                                    }
2276    
2277                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2278                            }
2279    
2280                            return (com.liferay.portal.model.Layout)returnObj;
2281                    }
2282                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2283                            _log.error(se, se);
2284    
2285                            throw se;
2286                    }
2287            }
2288    
2289            public static com.liferay.portal.model.Layout updatePriority(
2290                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2291                    long layoutId, int priority)
2292                    throws com.liferay.portal.kernel.exception.PortalException {
2293                    try {
2294                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2295                                            "updatePriority", _updatePriorityParameterTypes67);
2296    
2297                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2298                                            privateLayout, layoutId, priority);
2299    
2300                            Object returnObj = null;
2301    
2302                            try {
2303                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2304                            }
2305                            catch (Exception e) {
2306                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2307                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2308                                    }
2309    
2310                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2311                            }
2312    
2313                            return (com.liferay.portal.model.Layout)returnObj;
2314                    }
2315                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2316                            _log.error(se, se);
2317    
2318                            throw se;
2319                    }
2320            }
2321    
2322            public static com.liferay.portal.model.Layout updatePriority(
2323                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2324                    long layoutId, long nextLayoutId, long previousLayoutId)
2325                    throws com.liferay.portal.kernel.exception.PortalException {
2326                    try {
2327                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2328                                            "updatePriority", _updatePriorityParameterTypes68);
2329    
2330                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2331                                            privateLayout, layoutId, nextLayoutId, previousLayoutId);
2332    
2333                            Object returnObj = null;
2334    
2335                            try {
2336                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2337                            }
2338                            catch (Exception e) {
2339                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2340                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2341                                    }
2342    
2343                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2344                            }
2345    
2346                            return (com.liferay.portal.model.Layout)returnObj;
2347                    }
2348                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2349                            _log.error(se, se);
2350    
2351                            throw se;
2352                    }
2353            }
2354    
2355            public static com.liferay.portal.model.Layout updatePriority(
2356                    HttpPrincipal httpPrincipal, long plid, int priority)
2357                    throws com.liferay.portal.kernel.exception.PortalException {
2358                    try {
2359                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2360                                            "updatePriority", _updatePriorityParameterTypes69);
2361    
2362                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2363                                            priority);
2364    
2365                            Object returnObj = null;
2366    
2367                            try {
2368                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2369                            }
2370                            catch (Exception e) {
2371                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2372                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2373                                    }
2374    
2375                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2376                            }
2377    
2378                            return (com.liferay.portal.model.Layout)returnObj;
2379                    }
2380                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2381                            _log.error(se, se);
2382    
2383                            throw se;
2384                    }
2385            }
2386    
2387            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2388                    HttpPrincipal httpPrincipal,
2389                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2390                    java.io.File file)
2391                    throws com.liferay.portal.kernel.exception.PortalException {
2392                    try {
2393                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2394                                            "validateImportLayoutsFile",
2395                                            _validateImportLayoutsFileParameterTypes70);
2396    
2397                            MethodHandler methodHandler = new MethodHandler(methodKey,
2398                                            exportImportConfiguration, file);
2399    
2400                            Object returnObj = null;
2401    
2402                            try {
2403                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2404                            }
2405                            catch (Exception e) {
2406                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2407                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2408                                    }
2409    
2410                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2411                            }
2412    
2413                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2414                    }
2415                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2416                            _log.error(se, se);
2417    
2418                            throw se;
2419                    }
2420            }
2421    
2422            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2423                    HttpPrincipal httpPrincipal,
2424                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2425                    java.io.InputStream inputStream)
2426                    throws com.liferay.portal.kernel.exception.PortalException {
2427                    try {
2428                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2429                                            "validateImportLayoutsFile",
2430                                            _validateImportLayoutsFileParameterTypes71);
2431    
2432                            MethodHandler methodHandler = new MethodHandler(methodKey,
2433                                            exportImportConfiguration, inputStream);
2434    
2435                            Object returnObj = null;
2436    
2437                            try {
2438                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2439                            }
2440                            catch (Exception e) {
2441                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2442                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2443                                    }
2444    
2445                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2446                            }
2447    
2448                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2449                    }
2450                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2451                            _log.error(se, se);
2452    
2453                            throw se;
2454                    }
2455            }
2456    
2457            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2458                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2459                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2460                    java.io.File file)
2461                    throws com.liferay.portal.kernel.exception.PortalException {
2462                    try {
2463                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2464                                            "validateImportLayoutsFile",
2465                                            _validateImportLayoutsFileParameterTypes72);
2466    
2467                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2468                                            privateLayout, parameterMap, file);
2469    
2470                            Object returnObj = null;
2471    
2472                            try {
2473                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2474                            }
2475                            catch (Exception e) {
2476                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2477                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2478                                    }
2479    
2480                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2481                            }
2482    
2483                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2484                    }
2485                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2486                            _log.error(se, se);
2487    
2488                            throw se;
2489                    }
2490            }
2491    
2492            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2493                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2494                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2495                    java.io.InputStream inputStream)
2496                    throws com.liferay.portal.kernel.exception.PortalException {
2497                    try {
2498                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2499                                            "validateImportLayoutsFile",
2500                                            _validateImportLayoutsFileParameterTypes73);
2501    
2502                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2503                                            privateLayout, parameterMap, inputStream);
2504    
2505                            Object returnObj = null;
2506    
2507                            try {
2508                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2509                            }
2510                            catch (Exception e) {
2511                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2512                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2513                                    }
2514    
2515                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2516                            }
2517    
2518                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2519                    }
2520                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2521                            _log.error(se, se);
2522    
2523                            throw se;
2524                    }
2525            }
2526    
2527            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2528                    HttpPrincipal httpPrincipal,
2529                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2530                    java.io.File file)
2531                    throws com.liferay.portal.kernel.exception.PortalException {
2532                    try {
2533                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2534                                            "validateImportPortletInfo",
2535                                            _validateImportPortletInfoParameterTypes74);
2536    
2537                            MethodHandler methodHandler = new MethodHandler(methodKey,
2538                                            exportImportConfiguration, file);
2539    
2540                            Object returnObj = null;
2541    
2542                            try {
2543                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2544                            }
2545                            catch (Exception e) {
2546                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2547                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2548                                    }
2549    
2550                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2551                            }
2552    
2553                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2554                    }
2555                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2556                            _log.error(se, se);
2557    
2558                            throw se;
2559                    }
2560            }
2561    
2562            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2563                    HttpPrincipal httpPrincipal,
2564                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2565                    java.io.InputStream inputStream)
2566                    throws com.liferay.portal.kernel.exception.PortalException {
2567                    try {
2568                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2569                                            "validateImportPortletInfo",
2570                                            _validateImportPortletInfoParameterTypes75);
2571    
2572                            MethodHandler methodHandler = new MethodHandler(methodKey,
2573                                            exportImportConfiguration, inputStream);
2574    
2575                            Object returnObj = null;
2576    
2577                            try {
2578                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2579                            }
2580                            catch (Exception e) {
2581                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2582                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2583                                    }
2584    
2585                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2586                            }
2587    
2588                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2589                    }
2590                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2591                            _log.error(se, se);
2592    
2593                            throw se;
2594                    }
2595            }
2596    
2597            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2598                    HttpPrincipal httpPrincipal, long plid, long groupId,
2599                    java.lang.String portletId,
2600                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2601                    java.io.File file)
2602                    throws com.liferay.portal.kernel.exception.PortalException {
2603                    try {
2604                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2605                                            "validateImportPortletInfo",
2606                                            _validateImportPortletInfoParameterTypes76);
2607    
2608                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2609                                            groupId, portletId, parameterMap, file);
2610    
2611                            Object returnObj = null;
2612    
2613                            try {
2614                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2615                            }
2616                            catch (Exception e) {
2617                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2618                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2619                                    }
2620    
2621                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2622                            }
2623    
2624                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2625                    }
2626                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2627                            _log.error(se, se);
2628    
2629                            throw se;
2630                    }
2631            }
2632    
2633            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2634                    HttpPrincipal httpPrincipal, long plid, long groupId,
2635                    java.lang.String portletId,
2636                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2637                    java.io.InputStream inputStream)
2638                    throws com.liferay.portal.kernel.exception.PortalException {
2639                    try {
2640                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2641                                            "validateImportPortletInfo",
2642                                            _validateImportPortletInfoParameterTypes77);
2643    
2644                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2645                                            groupId, portletId, parameterMap, inputStream);
2646    
2647                            Object returnObj = null;
2648    
2649                            try {
2650                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2651                            }
2652                            catch (Exception e) {
2653                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2654                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2655                                    }
2656    
2657                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2658                            }
2659    
2660                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2661                    }
2662                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2663                            _log.error(se, se);
2664    
2665                            throw se;
2666                    }
2667            }
2668    
2669            private static Log _log = LogFactoryUtil.getLog(LayoutServiceHttp.class);
2670            private static final Class<?>[] _addLayoutParameterTypes0 = new Class[] {
2671                            long.class, boolean.class, long.class, java.util.Map.class,
2672                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2673                            java.util.Map.class, java.lang.String.class, boolean.class,
2674                            java.lang.String.class,
2675                            com.liferay.portal.service.ServiceContext.class
2676                    };
2677            private static final Class<?>[] _addLayoutParameterTypes1 = new Class[] {
2678                            long.class, boolean.class, long.class, java.util.Map.class,
2679                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2680                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2681                            boolean.class, java.util.Map.class,
2682                            com.liferay.portal.service.ServiceContext.class
2683                    };
2684            private static final Class<?>[] _addLayoutParameterTypes2 = new Class[] {
2685                            long.class, boolean.class, long.class, java.lang.String.class,
2686                            java.lang.String.class, java.lang.String.class,
2687                            java.lang.String.class, boolean.class, java.lang.String.class,
2688                            com.liferay.portal.service.ServiceContext.class
2689                    };
2690            private static final Class<?>[] _addTempFileEntryParameterTypes3 = new Class[] {
2691                            long.class, java.lang.String.class, java.lang.String.class,
2692                            java.io.InputStream.class, java.lang.String.class
2693                    };
2694            private static final Class<?>[] _deleteLayoutParameterTypes4 = new Class[] {
2695                            long.class, boolean.class, long.class,
2696                            com.liferay.portal.service.ServiceContext.class
2697                    };
2698            private static final Class<?>[] _deleteLayoutParameterTypes5 = new Class[] {
2699                            long.class, com.liferay.portal.service.ServiceContext.class
2700                    };
2701            private static final Class<?>[] _deleteTempFileEntryParameterTypes6 = new Class[] {
2702                            long.class, java.lang.String.class, java.lang.String.class
2703                    };
2704            private static final Class<?>[] _exportLayoutsParameterTypes7 = new Class[] {
2705                            long.class, boolean.class, long[].class, java.util.Map.class,
2706                            java.util.Date.class, java.util.Date.class
2707                    };
2708            private static final Class<?>[] _exportLayoutsParameterTypes8 = new Class[] {
2709                            long.class, boolean.class, java.util.Map.class, java.util.Date.class,
2710                            java.util.Date.class
2711                    };
2712            private static final Class<?>[] _exportLayoutsAsFileParameterTypes9 = new Class[] {
2713                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2714                    };
2715            private static final Class<?>[] _exportLayoutsAsFileParameterTypes10 = new Class[] {
2716                            long.class, boolean.class, long[].class, java.util.Map.class,
2717                            java.util.Date.class, java.util.Date.class
2718                    };
2719            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes11 =
2720                    new Class[] {
2721                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2722                    };
2723            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes12 =
2724                    new Class[] { long.class };
2725            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes13 =
2726                    new Class[] {
2727                            java.lang.String.class, long.class, boolean.class, long[].class,
2728                            java.util.Map.class, java.util.Date.class, java.util.Date.class
2729                    };
2730            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes14 =
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                            java.lang.String.class
2735                    };
2736            private static final Class<?>[] _exportPortletInfoParameterTypes15 = new Class[] {
2737                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2738                            java.util.Date.class, java.util.Date.class
2739                    };
2740            private static final Class<?>[] _exportPortletInfoParameterTypes16 = new Class[] {
2741                            long.class, java.lang.String.class, java.util.Map.class,
2742                            java.util.Date.class, java.util.Date.class
2743                    };
2744            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes17 = new Class[] {
2745                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2746                    };
2747            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes18 = new Class[] {
2748                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2749                            java.util.Date.class, java.util.Date.class
2750                    };
2751            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes19 = new Class[] {
2752                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2753                            java.util.Date.class
2754                    };
2755            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes20 =
2756                    new Class[] {
2757                            java.lang.String.class, long.class, long.class,
2758                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2759                            java.util.Date.class, java.lang.String.class
2760                    };
2761            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes21 =
2762                    new Class[] {
2763                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2764                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2765                    };
2766            private static final Class<?>[] _getAncestorLayoutsParameterTypes22 = new Class[] {
2767                            long.class
2768                    };
2769            private static final Class<?>[] _getDefaultPlidParameterTypes23 = new Class[] {
2770                            long.class, long.class, boolean.class, java.lang.String.class
2771                    };
2772            private static final Class<?>[] _getDefaultPlidParameterTypes24 = new Class[] {
2773                            long.class, long.class, java.lang.String.class
2774                    };
2775            private static final Class<?>[] _getLayoutByUuidAndGroupIdParameterTypes25 = new Class[] {
2776                            java.lang.String.class, long.class, boolean.class
2777                    };
2778            private static final Class<?>[] _getLayoutNameParameterTypes26 = new Class[] {
2779                            long.class, boolean.class, long.class, java.lang.String.class
2780                    };
2781            private static final Class<?>[] _getLayoutReferencesParameterTypes27 = new Class[] {
2782                            long.class, java.lang.String.class, java.lang.String.class,
2783                            java.lang.String.class
2784                    };
2785            private static final Class<?>[] _getLayoutsParameterTypes28 = new Class[] {
2786                            long.class, boolean.class
2787                    };
2788            private static final Class<?>[] _getLayoutsParameterTypes29 = new Class[] {
2789                            long.class, boolean.class, long.class
2790                    };
2791            private static final Class<?>[] _getLayoutsParameterTypes30 = new Class[] {
2792                            long.class, boolean.class, long.class, boolean.class, int.class,
2793                            int.class
2794                    };
2795            private static final Class<?>[] _getLayoutsCountParameterTypes31 = new Class[] {
2796                            long.class, boolean.class, long.class
2797                    };
2798            private static final Class<?>[] _getTempFileNamesParameterTypes32 = new Class[] {
2799                            long.class, java.lang.String.class
2800                    };
2801            private static final Class<?>[] _importLayoutsParameterTypes33 = new Class[] {
2802                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2803                            java.io.File.class
2804                    };
2805            private static final Class<?>[] _importLayoutsParameterTypes34 = new Class[] {
2806                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2807                            java.io.InputStream.class
2808                    };
2809            private static final Class<?>[] _importLayoutsParameterTypes35 = new Class[] {
2810                            long.class, boolean.class, java.util.Map.class, byte[].class
2811                    };
2812            private static final Class<?>[] _importLayoutsParameterTypes36 = new Class[] {
2813                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2814                    };
2815            private static final Class<?>[] _importLayoutsParameterTypes37 = new Class[] {
2816                            long.class, boolean.class, java.util.Map.class,
2817                            java.io.InputStream.class
2818                    };
2819            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes38 = new Class[] {
2820                            java.lang.String.class, long.class, boolean.class,
2821                            java.util.Map.class, java.io.File.class
2822                    };
2823            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes39 = new Class[] {
2824                            java.lang.String.class, long.class, boolean.class,
2825                            java.util.Map.class, java.io.InputStream.class
2826                    };
2827            private static final Class<?>[] _importPortletInfoParameterTypes40 = new Class[] {
2828                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2829                            java.io.File.class
2830                    };
2831            private static final Class<?>[] _importPortletInfoParameterTypes41 = new Class[] {
2832                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2833                            java.io.InputStream.class
2834                    };
2835            private static final Class<?>[] _importPortletInfoParameterTypes42 = new Class[] {
2836                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2837                            java.io.File.class
2838                    };
2839            private static final Class<?>[] _importPortletInfoParameterTypes43 = new Class[] {
2840                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2841                            java.io.InputStream.class
2842                    };
2843            private static final Class<?>[] _importPortletInfoParameterTypes44 = new Class[] {
2844                            java.lang.String.class, java.util.Map.class, java.io.File.class
2845                    };
2846            private static final Class<?>[] _importPortletInfoParameterTypes45 = new Class[] {
2847                            java.lang.String.class, java.util.Map.class,
2848                            java.io.InputStream.class
2849                    };
2850            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes46 =
2851                    new Class[] {
2852                            java.lang.String.class, long.class, long.class,
2853                            java.lang.String.class, java.util.Map.class, java.io.File.class
2854                    };
2855            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes47 =
2856                    new Class[] {
2857                            java.lang.String.class, long.class, long.class,
2858                            java.lang.String.class, java.util.Map.class,
2859                            java.io.InputStream.class
2860                    };
2861            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes48 =
2862                    new Class[] {
2863                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2864                            java.io.File.class
2865                    };
2866            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes49 =
2867                    new Class[] {
2868                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2869                            java.io.InputStream.class
2870                    };
2871            private static final Class<?>[] _schedulePublishToLiveParameterTypes50 = new Class[] {
2872                            long.class, long.class, boolean.class, long[].class,
2873                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2874                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2875                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2876                    };
2877            private static final Class<?>[] _schedulePublishToLiveParameterTypes51 = new Class[] {
2878                            long.class, long.class, boolean.class, long[].class,
2879                            java.util.Map.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<?>[] _schedulePublishToLiveParameterTypes52 = new Class[] {
2883                            long.class, long.class, boolean.class, java.util.Map.class,
2884                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2885                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2886                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2887                    };
2888            private static final Class<?>[] _schedulePublishToRemoteParameterTypes53 = new Class[] {
2889                            long.class, boolean.class, java.util.Map.class, java.util.Map.class,
2890                            java.lang.String.class, int.class, java.lang.String.class,
2891                            boolean.class, long.class, boolean.class, java.util.Date.class,
2892                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2893                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2894                    };
2895            private static final Class<?>[] _setLayoutsParameterTypes54 = new Class[] {
2896                            long.class, boolean.class, long.class, long[].class,
2897                            com.liferay.portal.service.ServiceContext.class
2898                    };
2899            private static final Class<?>[] _unschedulePublishToLiveParameterTypes55 = new Class[] {
2900                            long.class, java.lang.String.class, java.lang.String.class
2901                    };
2902            private static final Class<?>[] _unschedulePublishToRemoteParameterTypes56 = new Class[] {
2903                            long.class, java.lang.String.class, java.lang.String.class
2904                    };
2905            private static final Class<?>[] _updateIconImageParameterTypes57 = new Class[] {
2906                            long.class, byte[].class
2907                    };
2908            private static final Class<?>[] _updateLayoutParameterTypes58 = new Class[] {
2909                            long.class, boolean.class, long.class, long.class,
2910                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2911                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2912                            boolean.class, java.util.Map.class, boolean.class, byte[].class,
2913                            com.liferay.portal.service.ServiceContext.class
2914                    };
2915            private static final Class<?>[] _updateLayoutParameterTypes59 = new Class[] {
2916                            long.class, boolean.class, long.class, long.class,
2917                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2918                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2919                            boolean.class, java.lang.String.class, java.lang.Boolean.class,
2920                            byte[].class, com.liferay.portal.service.ServiceContext.class
2921                    };
2922            private static final Class<?>[] _updateLayoutParameterTypes60 = new Class[] {
2923                            long.class, boolean.class, long.class, java.lang.String.class
2924                    };
2925            private static final Class<?>[] _updateLookAndFeelParameterTypes61 = new Class[] {
2926                            long.class, boolean.class, long.class, java.lang.String.class,
2927                            java.lang.String.class, java.lang.String.class, boolean.class
2928                    };
2929            private static final Class<?>[] _updateNameParameterTypes62 = new Class[] {
2930                            long.class, boolean.class, long.class, java.lang.String.class,
2931                            java.lang.String.class
2932                    };
2933            private static final Class<?>[] _updateNameParameterTypes63 = new Class[] {
2934                            long.class, java.lang.String.class, java.lang.String.class
2935                    };
2936            private static final Class<?>[] _updateParentLayoutIdParameterTypes64 = new Class[] {
2937                            long.class, boolean.class, long.class, long.class
2938                    };
2939            private static final Class<?>[] _updateParentLayoutIdParameterTypes65 = new Class[] {
2940                            long.class, long.class
2941                    };
2942            private static final Class<?>[] _updateParentLayoutIdAndPriorityParameterTypes66 =
2943                    new Class[] { long.class, long.class, int.class };
2944            private static final Class<?>[] _updatePriorityParameterTypes67 = new Class[] {
2945                            long.class, boolean.class, long.class, int.class
2946                    };
2947            private static final Class<?>[] _updatePriorityParameterTypes68 = new Class[] {
2948                            long.class, boolean.class, long.class, long.class, long.class
2949                    };
2950            private static final Class<?>[] _updatePriorityParameterTypes69 = new Class[] {
2951                            long.class, int.class
2952                    };
2953            private static final Class<?>[] _validateImportLayoutsFileParameterTypes70 = new Class[] {
2954                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2955                            java.io.File.class
2956                    };
2957            private static final Class<?>[] _validateImportLayoutsFileParameterTypes71 = new Class[] {
2958                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2959                            java.io.InputStream.class
2960                    };
2961            private static final Class<?>[] _validateImportLayoutsFileParameterTypes72 = new Class[] {
2962                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2963                    };
2964            private static final Class<?>[] _validateImportLayoutsFileParameterTypes73 = new Class[] {
2965                            long.class, boolean.class, java.util.Map.class,
2966                            java.io.InputStream.class
2967                    };
2968            private static final Class<?>[] _validateImportPortletInfoParameterTypes74 = new Class[] {
2969                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2970                            java.io.File.class
2971                    };
2972            private static final Class<?>[] _validateImportPortletInfoParameterTypes75 = new Class[] {
2973                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2974                            java.io.InputStream.class
2975                    };
2976            private static final Class<?>[] _validateImportPortletInfoParameterTypes76 = new Class[] {
2977                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2978                            java.io.File.class
2979                    };
2980            private static final Class<?>[] _validateImportPortletInfoParameterTypes77 = new Class[] {
2981                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2982                            java.io.InputStream.class
2983                    };
2984    }