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                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1735                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1736                    java.lang.String scope, java.util.Date startDate,
1737                    java.util.Date endDate, java.lang.String groupName,
1738                    java.lang.String cronText, java.util.Date schedulerStartDate,
1739                    java.util.Date schedulerEndDate, java.lang.String description)
1740                    throws com.liferay.portal.kernel.exception.PortalException {
1741                    try {
1742                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1743                                            "schedulePublishToLive",
1744                                            _schedulePublishToLiveParameterTypes51);
1745    
1746                            MethodHandler methodHandler = new MethodHandler(methodKey,
1747                                            sourceGroupId, targetGroupId, privateLayout, layoutIdMap,
1748                                            parameterMap, scope, startDate, endDate, groupName,
1749                                            cronText, schedulerStartDate, schedulerEndDate, description);
1750    
1751                            try {
1752                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1753                            }
1754                            catch (Exception e) {
1755                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1756                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1757                                    }
1758    
1759                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1760                            }
1761                    }
1762                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1763                            _log.error(se, se);
1764    
1765                            throw se;
1766                    }
1767            }
1768    
1769            public static void schedulePublishToRemote(HttpPrincipal httpPrincipal,
1770                    long sourceGroupId, boolean privateLayout,
1771                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1772                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1773                    java.lang.String remoteAddress, int remotePort,
1774                    java.lang.String remotePathContext, boolean secureConnection,
1775                    long remoteGroupId, boolean remotePrivateLayout,
1776                    java.util.Date startDate, java.util.Date endDate,
1777                    java.lang.String groupName, java.lang.String cronText,
1778                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1779                    java.lang.String description)
1780                    throws com.liferay.portal.kernel.exception.PortalException {
1781                    try {
1782                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1783                                            "schedulePublishToRemote",
1784                                            _schedulePublishToRemoteParameterTypes52);
1785    
1786                            MethodHandler methodHandler = new MethodHandler(methodKey,
1787                                            sourceGroupId, privateLayout, layoutIdMap, parameterMap,
1788                                            remoteAddress, remotePort, remotePathContext,
1789                                            secureConnection, remoteGroupId, remotePrivateLayout,
1790                                            startDate, endDate, groupName, cronText,
1791                                            schedulerStartDate, schedulerEndDate, description);
1792    
1793                            try {
1794                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1795                            }
1796                            catch (Exception e) {
1797                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1798                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1799                                    }
1800    
1801                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1802                            }
1803                    }
1804                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1805                            _log.error(se, se);
1806    
1807                            throw se;
1808                    }
1809            }
1810    
1811            public static void setLayouts(HttpPrincipal httpPrincipal, long groupId,
1812                    boolean privateLayout, long parentLayoutId, long[] layoutIds,
1813                    com.liferay.portal.service.ServiceContext serviceContext)
1814                    throws com.liferay.portal.kernel.exception.PortalException {
1815                    try {
1816                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1817                                            "setLayouts", _setLayoutsParameterTypes53);
1818    
1819                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1820                                            privateLayout, parentLayoutId, layoutIds, serviceContext);
1821    
1822                            try {
1823                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1824                            }
1825                            catch (Exception e) {
1826                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1827                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1828                                    }
1829    
1830                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1831                            }
1832                    }
1833                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1834                            _log.error(se, se);
1835    
1836                            throw se;
1837                    }
1838            }
1839    
1840            public static void unschedulePublishToLive(HttpPrincipal httpPrincipal,
1841                    long groupId, java.lang.String jobName, java.lang.String groupName)
1842                    throws com.liferay.portal.kernel.exception.PortalException {
1843                    try {
1844                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1845                                            "unschedulePublishToLive",
1846                                            _unschedulePublishToLiveParameterTypes54);
1847    
1848                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1849                                            jobName, groupName);
1850    
1851                            try {
1852                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1853                            }
1854                            catch (Exception e) {
1855                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1856                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1857                                    }
1858    
1859                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1860                            }
1861                    }
1862                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1863                            _log.error(se, se);
1864    
1865                            throw se;
1866                    }
1867            }
1868    
1869            public static void unschedulePublishToRemote(HttpPrincipal httpPrincipal,
1870                    long groupId, java.lang.String jobName, java.lang.String groupName)
1871                    throws com.liferay.portal.kernel.exception.PortalException {
1872                    try {
1873                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1874                                            "unschedulePublishToRemote",
1875                                            _unschedulePublishToRemoteParameterTypes55);
1876    
1877                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1878                                            jobName, groupName);
1879    
1880                            try {
1881                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1882                            }
1883                            catch (Exception e) {
1884                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1885                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1886                                    }
1887    
1888                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1889                            }
1890                    }
1891                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1892                            _log.error(se, se);
1893    
1894                            throw se;
1895                    }
1896            }
1897    
1898            public static com.liferay.portal.model.Layout updateIconImage(
1899                    HttpPrincipal httpPrincipal, long plid, byte[] bytes)
1900                    throws com.liferay.portal.kernel.exception.PortalException {
1901                    try {
1902                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1903                                            "updateIconImage", _updateIconImageParameterTypes56);
1904    
1905                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1906                                            bytes);
1907    
1908                            Object returnObj = null;
1909    
1910                            try {
1911                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1912                            }
1913                            catch (Exception e) {
1914                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1915                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1916                                    }
1917    
1918                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1919                            }
1920    
1921                            return (com.liferay.portal.model.Layout)returnObj;
1922                    }
1923                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1924                            _log.error(se, se);
1925    
1926                            throw se;
1927                    }
1928            }
1929    
1930            public static com.liferay.portal.model.Layout updateLayout(
1931                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1932                    long layoutId, long parentLayoutId,
1933                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1934                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1935                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1936                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1937                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1938                    java.lang.String type, boolean hidden,
1939                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
1940                    boolean iconImage, byte[] iconBytes,
1941                    com.liferay.portal.service.ServiceContext serviceContext)
1942                    throws com.liferay.portal.kernel.exception.PortalException {
1943                    try {
1944                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1945                                            "updateLayout", _updateLayoutParameterTypes57);
1946    
1947                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1948                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1949                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1950                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
1951                                            serviceContext);
1952    
1953                            Object returnObj = null;
1954    
1955                            try {
1956                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1957                            }
1958                            catch (Exception e) {
1959                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1960                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1961                                    }
1962    
1963                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1964                            }
1965    
1966                            return (com.liferay.portal.model.Layout)returnObj;
1967                    }
1968                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1969                            _log.error(se, se);
1970    
1971                            throw se;
1972                    }
1973            }
1974    
1975            public static com.liferay.portal.model.Layout updateLayout(
1976                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1977                    long layoutId, long parentLayoutId,
1978                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1979                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1980                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1981                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1982                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1983                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
1984                    java.lang.Boolean iconImage, byte[] iconBytes,
1985                    com.liferay.portal.service.ServiceContext serviceContext)
1986                    throws com.liferay.portal.kernel.exception.PortalException {
1987                    try {
1988                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1989                                            "updateLayout", _updateLayoutParameterTypes58);
1990    
1991                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1992                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1993                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1994                                            type, hidden, friendlyURL, iconImage, iconBytes,
1995                                            serviceContext);
1996    
1997                            Object returnObj = null;
1998    
1999                            try {
2000                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2001                            }
2002                            catch (Exception e) {
2003                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2004                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2005                                    }
2006    
2007                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2008                            }
2009    
2010                            return (com.liferay.portal.model.Layout)returnObj;
2011                    }
2012                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2013                            _log.error(se, se);
2014    
2015                            throw se;
2016                    }
2017            }
2018    
2019            public static com.liferay.portal.model.Layout updateLayout(
2020                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2021                    long layoutId, java.lang.String typeSettings)
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, typeSettings);
2029    
2030                            Object returnObj = null;
2031    
2032                            try {
2033                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2034                            }
2035                            catch (Exception e) {
2036                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2037                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2038                                    }
2039    
2040                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2041                            }
2042    
2043                            return (com.liferay.portal.model.Layout)returnObj;
2044                    }
2045                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2046                            _log.error(se, se);
2047    
2048                            throw se;
2049                    }
2050            }
2051    
2052            public static com.liferay.portal.model.Layout updateLookAndFeel(
2053                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2054                    long layoutId, java.lang.String themeId,
2055                    java.lang.String colorSchemeId, java.lang.String css, boolean wapTheme)
2056                    throws com.liferay.portal.kernel.exception.PortalException {
2057                    try {
2058                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2059                                            "updateLookAndFeel", _updateLookAndFeelParameterTypes60);
2060    
2061                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2062                                            privateLayout, layoutId, themeId, colorSchemeId, css,
2063                                            wapTheme);
2064    
2065                            Object returnObj = null;
2066    
2067                            try {
2068                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2069                            }
2070                            catch (Exception e) {
2071                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2072                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2073                                    }
2074    
2075                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2076                            }
2077    
2078                            return (com.liferay.portal.model.Layout)returnObj;
2079                    }
2080                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2081                            _log.error(se, se);
2082    
2083                            throw se;
2084                    }
2085            }
2086    
2087            public static com.liferay.portal.model.Layout updateName(
2088                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2089                    long layoutId, java.lang.String name, java.lang.String languageId)
2090                    throws com.liferay.portal.kernel.exception.PortalException {
2091                    try {
2092                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2093                                            "updateName", _updateNameParameterTypes61);
2094    
2095                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2096                                            privateLayout, layoutId, name, languageId);
2097    
2098                            Object returnObj = null;
2099    
2100                            try {
2101                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2102                            }
2103                            catch (Exception e) {
2104                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2105                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2106                                    }
2107    
2108                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2109                            }
2110    
2111                            return (com.liferay.portal.model.Layout)returnObj;
2112                    }
2113                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2114                            _log.error(se, se);
2115    
2116                            throw se;
2117                    }
2118            }
2119    
2120            public static com.liferay.portal.model.Layout updateName(
2121                    HttpPrincipal httpPrincipal, long plid, java.lang.String name,
2122                    java.lang.String languageId)
2123                    throws com.liferay.portal.kernel.exception.PortalException {
2124                    try {
2125                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2126                                            "updateName", _updateNameParameterTypes62);
2127    
2128                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2129                                            name, languageId);
2130    
2131                            Object returnObj = null;
2132    
2133                            try {
2134                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2135                            }
2136                            catch (Exception e) {
2137                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2138                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2139                                    }
2140    
2141                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2142                            }
2143    
2144                            return (com.liferay.portal.model.Layout)returnObj;
2145                    }
2146                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2147                            _log.error(se, se);
2148    
2149                            throw se;
2150                    }
2151            }
2152    
2153            public static com.liferay.portal.model.Layout updateParentLayoutId(
2154                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2155                    long layoutId, long parentLayoutId)
2156                    throws com.liferay.portal.kernel.exception.PortalException {
2157                    try {
2158                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2159                                            "updateParentLayoutId",
2160                                            _updateParentLayoutIdParameterTypes63);
2161    
2162                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2163                                            privateLayout, layoutId, parentLayoutId);
2164    
2165                            Object returnObj = null;
2166    
2167                            try {
2168                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2169                            }
2170                            catch (Exception e) {
2171                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2172                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2173                                    }
2174    
2175                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2176                            }
2177    
2178                            return (com.liferay.portal.model.Layout)returnObj;
2179                    }
2180                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2181                            _log.error(se, se);
2182    
2183                            throw se;
2184                    }
2185            }
2186    
2187            public static com.liferay.portal.model.Layout updateParentLayoutId(
2188                    HttpPrincipal httpPrincipal, long plid, long parentPlid)
2189                    throws com.liferay.portal.kernel.exception.PortalException {
2190                    try {
2191                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2192                                            "updateParentLayoutId",
2193                                            _updateParentLayoutIdParameterTypes64);
2194    
2195                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2196                                            parentPlid);
2197    
2198                            Object returnObj = null;
2199    
2200                            try {
2201                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2202                            }
2203                            catch (Exception e) {
2204                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2205                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2206                                    }
2207    
2208                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2209                            }
2210    
2211                            return (com.liferay.portal.model.Layout)returnObj;
2212                    }
2213                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2214                            _log.error(se, se);
2215    
2216                            throw se;
2217                    }
2218            }
2219    
2220            public static com.liferay.portal.model.Layout updateParentLayoutIdAndPriority(
2221                    HttpPrincipal httpPrincipal, long plid, long parentPlid, int priority)
2222                    throws com.liferay.portal.kernel.exception.PortalException {
2223                    try {
2224                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2225                                            "updateParentLayoutIdAndPriority",
2226                                            _updateParentLayoutIdAndPriorityParameterTypes65);
2227    
2228                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2229                                            parentPlid, priority);
2230    
2231                            Object returnObj = null;
2232    
2233                            try {
2234                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2235                            }
2236                            catch (Exception e) {
2237                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2238                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2239                                    }
2240    
2241                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2242                            }
2243    
2244                            return (com.liferay.portal.model.Layout)returnObj;
2245                    }
2246                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2247                            _log.error(se, se);
2248    
2249                            throw se;
2250                    }
2251            }
2252    
2253            public static com.liferay.portal.model.Layout updatePriority(
2254                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2255                    long layoutId, int priority)
2256                    throws com.liferay.portal.kernel.exception.PortalException {
2257                    try {
2258                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2259                                            "updatePriority", _updatePriorityParameterTypes66);
2260    
2261                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2262                                            privateLayout, layoutId, priority);
2263    
2264                            Object returnObj = null;
2265    
2266                            try {
2267                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2268                            }
2269                            catch (Exception e) {
2270                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2271                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2272                                    }
2273    
2274                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2275                            }
2276    
2277                            return (com.liferay.portal.model.Layout)returnObj;
2278                    }
2279                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2280                            _log.error(se, se);
2281    
2282                            throw se;
2283                    }
2284            }
2285    
2286            public static com.liferay.portal.model.Layout updatePriority(
2287                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2288                    long layoutId, long nextLayoutId, long previousLayoutId)
2289                    throws com.liferay.portal.kernel.exception.PortalException {
2290                    try {
2291                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2292                                            "updatePriority", _updatePriorityParameterTypes67);
2293    
2294                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2295                                            privateLayout, layoutId, nextLayoutId, previousLayoutId);
2296    
2297                            Object returnObj = null;
2298    
2299                            try {
2300                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2301                            }
2302                            catch (Exception e) {
2303                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2304                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2305                                    }
2306    
2307                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2308                            }
2309    
2310                            return (com.liferay.portal.model.Layout)returnObj;
2311                    }
2312                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2313                            _log.error(se, se);
2314    
2315                            throw se;
2316                    }
2317            }
2318    
2319            public static com.liferay.portal.model.Layout updatePriority(
2320                    HttpPrincipal httpPrincipal, long plid, int priority)
2321                    throws com.liferay.portal.kernel.exception.PortalException {
2322                    try {
2323                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2324                                            "updatePriority", _updatePriorityParameterTypes68);
2325    
2326                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
2327                                            priority);
2328    
2329                            Object returnObj = null;
2330    
2331                            try {
2332                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2333                            }
2334                            catch (Exception e) {
2335                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2336                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2337                                    }
2338    
2339                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2340                            }
2341    
2342                            return (com.liferay.portal.model.Layout)returnObj;
2343                    }
2344                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2345                            _log.error(se, se);
2346    
2347                            throw se;
2348                    }
2349            }
2350    
2351            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2352                    HttpPrincipal httpPrincipal,
2353                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2354                    java.io.File file)
2355                    throws com.liferay.portal.kernel.exception.PortalException {
2356                    try {
2357                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2358                                            "validateImportLayoutsFile",
2359                                            _validateImportLayoutsFileParameterTypes69);
2360    
2361                            MethodHandler methodHandler = new MethodHandler(methodKey,
2362                                            exportImportConfiguration, file);
2363    
2364                            Object returnObj = null;
2365    
2366                            try {
2367                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2368                            }
2369                            catch (Exception e) {
2370                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2371                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2372                                    }
2373    
2374                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2375                            }
2376    
2377                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2378                    }
2379                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2380                            _log.error(se, se);
2381    
2382                            throw se;
2383                    }
2384            }
2385    
2386            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2387                    HttpPrincipal httpPrincipal,
2388                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2389                    java.io.InputStream inputStream)
2390                    throws com.liferay.portal.kernel.exception.PortalException {
2391                    try {
2392                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2393                                            "validateImportLayoutsFile",
2394                                            _validateImportLayoutsFileParameterTypes70);
2395    
2396                            MethodHandler methodHandler = new MethodHandler(methodKey,
2397                                            exportImportConfiguration, inputStream);
2398    
2399                            Object returnObj = null;
2400    
2401                            try {
2402                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2403                            }
2404                            catch (Exception e) {
2405                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2406                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2407                                    }
2408    
2409                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2410                            }
2411    
2412                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2413                    }
2414                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2415                            _log.error(se, se);
2416    
2417                            throw se;
2418                    }
2419            }
2420    
2421            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2422                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2423                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2424                    java.io.File file)
2425                    throws com.liferay.portal.kernel.exception.PortalException {
2426                    try {
2427                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2428                                            "validateImportLayoutsFile",
2429                                            _validateImportLayoutsFileParameterTypes71);
2430    
2431                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2432                                            privateLayout, parameterMap, file);
2433    
2434                            Object returnObj = null;
2435    
2436                            try {
2437                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2438                            }
2439                            catch (Exception e) {
2440                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2441                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2442                                    }
2443    
2444                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2445                            }
2446    
2447                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2448                    }
2449                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2450                            _log.error(se, se);
2451    
2452                            throw se;
2453                    }
2454            }
2455    
2456            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportLayoutsFile(
2457                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2458                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2459                    java.io.InputStream inputStream)
2460                    throws com.liferay.portal.kernel.exception.PortalException {
2461                    try {
2462                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2463                                            "validateImportLayoutsFile",
2464                                            _validateImportLayoutsFileParameterTypes72);
2465    
2466                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2467                                            privateLayout, parameterMap, inputStream);
2468    
2469                            Object returnObj = null;
2470    
2471                            try {
2472                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2473                            }
2474                            catch (Exception e) {
2475                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2476                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2477                                    }
2478    
2479                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2480                            }
2481    
2482                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2483                    }
2484                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2485                            _log.error(se, se);
2486    
2487                            throw se;
2488                    }
2489            }
2490    
2491            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2492                    HttpPrincipal httpPrincipal,
2493                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2494                    java.io.File file)
2495                    throws com.liferay.portal.kernel.exception.PortalException {
2496                    try {
2497                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2498                                            "validateImportPortletInfo",
2499                                            _validateImportPortletInfoParameterTypes73);
2500    
2501                            MethodHandler methodHandler = new MethodHandler(methodKey,
2502                                            exportImportConfiguration, file);
2503    
2504                            Object returnObj = null;
2505    
2506                            try {
2507                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2508                            }
2509                            catch (Exception e) {
2510                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2511                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2512                                    }
2513    
2514                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2515                            }
2516    
2517                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2518                    }
2519                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2520                            _log.error(se, se);
2521    
2522                            throw se;
2523                    }
2524            }
2525    
2526            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2527                    HttpPrincipal httpPrincipal,
2528                    com.liferay.portlet.exportimport.model.ExportImportConfiguration exportImportConfiguration,
2529                    java.io.InputStream inputStream)
2530                    throws com.liferay.portal.kernel.exception.PortalException {
2531                    try {
2532                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2533                                            "validateImportPortletInfo",
2534                                            _validateImportPortletInfoParameterTypes74);
2535    
2536                            MethodHandler methodHandler = new MethodHandler(methodKey,
2537                                            exportImportConfiguration, inputStream);
2538    
2539                            Object returnObj = null;
2540    
2541                            try {
2542                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
2543                            }
2544                            catch (Exception e) {
2545                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
2546                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
2547                                    }
2548    
2549                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
2550                            }
2551    
2552                            return (com.liferay.portlet.exportimport.lar.MissingReferences)returnObj;
2553                    }
2554                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2555                            _log.error(se, se);
2556    
2557                            throw se;
2558                    }
2559            }
2560    
2561            public static com.liferay.portlet.exportimport.lar.MissingReferences validateImportPortletInfo(
2562                    HttpPrincipal httpPrincipal, long plid, long groupId,
2563                    java.lang.String portletId,
2564                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2565                    java.io.File file)
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, plid,
2573                                            groupId, portletId, parameterMap, file);
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.InputStream inputStream)
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, inputStream);
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            private static Log _log = LogFactoryUtil.getLog(LayoutServiceHttp.class);
2634            private static final Class<?>[] _addLayoutParameterTypes0 = new Class[] {
2635                            long.class, boolean.class, long.class, java.util.Map.class,
2636                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2637                            java.util.Map.class, java.lang.String.class, boolean.class,
2638                            java.lang.String.class,
2639                            com.liferay.portal.service.ServiceContext.class
2640                    };
2641            private static final Class<?>[] _addLayoutParameterTypes1 = new Class[] {
2642                            long.class, boolean.class, long.class, java.util.Map.class,
2643                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2644                            java.util.Map.class, java.lang.String.class, java.lang.String.class,
2645                            boolean.class, java.util.Map.class,
2646                            com.liferay.portal.service.ServiceContext.class
2647                    };
2648            private static final Class<?>[] _addLayoutParameterTypes2 = new Class[] {
2649                            long.class, boolean.class, long.class, java.lang.String.class,
2650                            java.lang.String.class, java.lang.String.class,
2651                            java.lang.String.class, boolean.class, java.lang.String.class,
2652                            com.liferay.portal.service.ServiceContext.class
2653                    };
2654            private static final Class<?>[] _addTempFileEntryParameterTypes3 = new Class[] {
2655                            long.class, java.lang.String.class, java.lang.String.class,
2656                            java.io.InputStream.class, java.lang.String.class
2657                    };
2658            private static final Class<?>[] _deleteLayoutParameterTypes4 = new Class[] {
2659                            long.class, boolean.class, long.class,
2660                            com.liferay.portal.service.ServiceContext.class
2661                    };
2662            private static final Class<?>[] _deleteLayoutParameterTypes5 = new Class[] {
2663                            long.class, com.liferay.portal.service.ServiceContext.class
2664                    };
2665            private static final Class<?>[] _deleteTempFileEntryParameterTypes6 = new Class[] {
2666                            long.class, java.lang.String.class, java.lang.String.class
2667                    };
2668            private static final Class<?>[] _exportLayoutsParameterTypes7 = new Class[] {
2669                            long.class, boolean.class, long[].class, java.util.Map.class,
2670                            java.util.Date.class, java.util.Date.class
2671                    };
2672            private static final Class<?>[] _exportLayoutsParameterTypes8 = new Class[] {
2673                            long.class, boolean.class, java.util.Map.class, java.util.Date.class,
2674                            java.util.Date.class
2675                    };
2676            private static final Class<?>[] _exportLayoutsAsFileParameterTypes9 = new Class[] {
2677                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2678                    };
2679            private static final Class<?>[] _exportLayoutsAsFileParameterTypes10 = new Class[] {
2680                            long.class, boolean.class, long[].class, java.util.Map.class,
2681                            java.util.Date.class, java.util.Date.class
2682                    };
2683            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes11 =
2684                    new Class[] {
2685                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2686                    };
2687            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes12 =
2688                    new Class[] { long.class };
2689            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes13 =
2690                    new Class[] {
2691                            java.lang.String.class, long.class, boolean.class, long[].class,
2692                            java.util.Map.class, java.util.Date.class, java.util.Date.class
2693                    };
2694            private static final Class<?>[] _exportLayoutsAsFileInBackgroundParameterTypes14 =
2695                    new Class[] {
2696                            java.lang.String.class, long.class, boolean.class, long[].class,
2697                            java.util.Map.class, java.util.Date.class, java.util.Date.class,
2698                            java.lang.String.class
2699                    };
2700            private static final Class<?>[] _exportPortletInfoParameterTypes15 = new Class[] {
2701                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2702                            java.util.Date.class, java.util.Date.class
2703                    };
2704            private static final Class<?>[] _exportPortletInfoParameterTypes16 = new Class[] {
2705                            long.class, java.lang.String.class, java.util.Map.class,
2706                            java.util.Date.class, java.util.Date.class
2707                    };
2708            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes17 = new Class[] {
2709                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class
2710                    };
2711            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes18 = new Class[] {
2712                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2713                            java.util.Date.class, java.util.Date.class
2714                    };
2715            private static final Class<?>[] _exportPortletInfoAsFileParameterTypes19 = new Class[] {
2716                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2717                            java.util.Date.class
2718                    };
2719            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes20 =
2720                    new Class[] {
2721                            java.lang.String.class, long.class, long.class,
2722                            java.lang.String.class, java.util.Map.class, java.util.Date.class,
2723                            java.util.Date.class, java.lang.String.class
2724                    };
2725            private static final Class<?>[] _exportPortletInfoAsFileInBackgroundParameterTypes21 =
2726                    new Class[] {
2727                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2728                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2729                    };
2730            private static final Class<?>[] _getAncestorLayoutsParameterTypes22 = new Class[] {
2731                            long.class
2732                    };
2733            private static final Class<?>[] _getDefaultPlidParameterTypes23 = new Class[] {
2734                            long.class, long.class, boolean.class, java.lang.String.class
2735                    };
2736            private static final Class<?>[] _getDefaultPlidParameterTypes24 = new Class[] {
2737                            long.class, long.class, java.lang.String.class
2738                    };
2739            private static final Class<?>[] _getLayoutByUuidAndGroupIdParameterTypes25 = new Class[] {
2740                            java.lang.String.class, long.class, boolean.class
2741                    };
2742            private static final Class<?>[] _getLayoutNameParameterTypes26 = new Class[] {
2743                            long.class, boolean.class, long.class, java.lang.String.class
2744                    };
2745            private static final Class<?>[] _getLayoutReferencesParameterTypes27 = new Class[] {
2746                            long.class, java.lang.String.class, java.lang.String.class,
2747                            java.lang.String.class
2748                    };
2749            private static final Class<?>[] _getLayoutsParameterTypes28 = new Class[] {
2750                            long.class, boolean.class
2751                    };
2752            private static final Class<?>[] _getLayoutsParameterTypes29 = new Class[] {
2753                            long.class, boolean.class, long.class
2754                    };
2755            private static final Class<?>[] _getLayoutsParameterTypes30 = new Class[] {
2756                            long.class, boolean.class, long.class, boolean.class, int.class,
2757                            int.class
2758                    };
2759            private static final Class<?>[] _getLayoutsCountParameterTypes31 = new Class[] {
2760                            long.class, boolean.class, long.class
2761                    };
2762            private static final Class<?>[] _getTempFileNamesParameterTypes32 = new Class[] {
2763                            long.class, java.lang.String.class
2764                    };
2765            private static final Class<?>[] _importLayoutsParameterTypes33 = new Class[] {
2766                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2767                            java.io.File.class
2768                    };
2769            private static final Class<?>[] _importLayoutsParameterTypes34 = new Class[] {
2770                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2771                            java.io.InputStream.class
2772                    };
2773            private static final Class<?>[] _importLayoutsParameterTypes35 = new Class[] {
2774                            long.class, boolean.class, java.util.Map.class, byte[].class
2775                    };
2776            private static final Class<?>[] _importLayoutsParameterTypes36 = new Class[] {
2777                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2778                    };
2779            private static final Class<?>[] _importLayoutsParameterTypes37 = new Class[] {
2780                            long.class, boolean.class, java.util.Map.class,
2781                            java.io.InputStream.class
2782                    };
2783            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes38 = new Class[] {
2784                            java.lang.String.class, long.class, boolean.class,
2785                            java.util.Map.class, java.io.File.class
2786                    };
2787            private static final Class<?>[] _importLayoutsInBackgroundParameterTypes39 = new Class[] {
2788                            java.lang.String.class, long.class, boolean.class,
2789                            java.util.Map.class, java.io.InputStream.class
2790                    };
2791            private static final Class<?>[] _importPortletInfoParameterTypes40 = new Class[] {
2792                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2793                            java.io.File.class
2794                    };
2795            private static final Class<?>[] _importPortletInfoParameterTypes41 = new Class[] {
2796                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2797                            java.io.InputStream.class
2798                    };
2799            private static final Class<?>[] _importPortletInfoParameterTypes42 = new Class[] {
2800                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2801                            java.io.File.class
2802                    };
2803            private static final Class<?>[] _importPortletInfoParameterTypes43 = new Class[] {
2804                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2805                            java.io.InputStream.class
2806                    };
2807            private static final Class<?>[] _importPortletInfoParameterTypes44 = new Class[] {
2808                            java.lang.String.class, java.util.Map.class, java.io.File.class
2809                    };
2810            private static final Class<?>[] _importPortletInfoParameterTypes45 = new Class[] {
2811                            java.lang.String.class, java.util.Map.class,
2812                            java.io.InputStream.class
2813                    };
2814            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes46 =
2815                    new Class[] {
2816                            java.lang.String.class, long.class, long.class,
2817                            java.lang.String.class, java.util.Map.class, java.io.File.class
2818                    };
2819            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes47 =
2820                    new Class[] {
2821                            java.lang.String.class, long.class, long.class,
2822                            java.lang.String.class, java.util.Map.class,
2823                            java.io.InputStream.class
2824                    };
2825            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes48 =
2826                    new Class[] {
2827                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2828                            java.io.File.class
2829                    };
2830            private static final Class<?>[] _importPortletInfoInBackgroundParameterTypes49 =
2831                    new Class[] {
2832                            java.lang.String.class, java.lang.String.class, java.util.Map.class,
2833                            java.io.InputStream.class
2834                    };
2835            private static final Class<?>[] _schedulePublishToLiveParameterTypes50 = new Class[] {
2836                            long.class, long.class, boolean.class, long[].class,
2837                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2838                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2839                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2840                    };
2841            private static final Class<?>[] _schedulePublishToLiveParameterTypes51 = new Class[] {
2842                            long.class, long.class, boolean.class, java.util.Map.class,
2843                            java.util.Map.class, java.lang.String.class, java.util.Date.class,
2844                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2845                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2846                    };
2847            private static final Class<?>[] _schedulePublishToRemoteParameterTypes52 = new Class[] {
2848                            long.class, boolean.class, java.util.Map.class, java.util.Map.class,
2849                            java.lang.String.class, int.class, java.lang.String.class,
2850                            boolean.class, long.class, boolean.class, java.util.Date.class,
2851                            java.util.Date.class, java.lang.String.class, java.lang.String.class,
2852                            java.util.Date.class, java.util.Date.class, java.lang.String.class
2853                    };
2854            private static final Class<?>[] _setLayoutsParameterTypes53 = new Class[] {
2855                            long.class, boolean.class, long.class, long[].class,
2856                            com.liferay.portal.service.ServiceContext.class
2857                    };
2858            private static final Class<?>[] _unschedulePublishToLiveParameterTypes54 = new Class[] {
2859                            long.class, java.lang.String.class, java.lang.String.class
2860                    };
2861            private static final Class<?>[] _unschedulePublishToRemoteParameterTypes55 = new Class[] {
2862                            long.class, java.lang.String.class, java.lang.String.class
2863                    };
2864            private static final Class<?>[] _updateIconImageParameterTypes56 = new Class[] {
2865                            long.class, byte[].class
2866                    };
2867            private static final Class<?>[] _updateLayoutParameterTypes57 = new Class[] {
2868                            long.class, boolean.class, long.class, long.class,
2869                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2870                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2871                            boolean.class, java.util.Map.class, boolean.class, byte[].class,
2872                            com.liferay.portal.service.ServiceContext.class
2873                    };
2874            private static final Class<?>[] _updateLayoutParameterTypes58 = new Class[] {
2875                            long.class, boolean.class, long.class, long.class,
2876                            java.util.Map.class, java.util.Map.class, java.util.Map.class,
2877                            java.util.Map.class, java.util.Map.class, java.lang.String.class,
2878                            boolean.class, java.lang.String.class, java.lang.Boolean.class,
2879                            byte[].class, com.liferay.portal.service.ServiceContext.class
2880                    };
2881            private static final Class<?>[] _updateLayoutParameterTypes59 = new Class[] {
2882                            long.class, boolean.class, long.class, java.lang.String.class
2883                    };
2884            private static final Class<?>[] _updateLookAndFeelParameterTypes60 = new Class[] {
2885                            long.class, boolean.class, long.class, java.lang.String.class,
2886                            java.lang.String.class, java.lang.String.class, boolean.class
2887                    };
2888            private static final Class<?>[] _updateNameParameterTypes61 = new Class[] {
2889                            long.class, boolean.class, long.class, java.lang.String.class,
2890                            java.lang.String.class
2891                    };
2892            private static final Class<?>[] _updateNameParameterTypes62 = new Class[] {
2893                            long.class, java.lang.String.class, java.lang.String.class
2894                    };
2895            private static final Class<?>[] _updateParentLayoutIdParameterTypes63 = new Class[] {
2896                            long.class, boolean.class, long.class, long.class
2897                    };
2898            private static final Class<?>[] _updateParentLayoutIdParameterTypes64 = new Class[] {
2899                            long.class, long.class
2900                    };
2901            private static final Class<?>[] _updateParentLayoutIdAndPriorityParameterTypes65 =
2902                    new Class[] { long.class, long.class, int.class };
2903            private static final Class<?>[] _updatePriorityParameterTypes66 = new Class[] {
2904                            long.class, boolean.class, long.class, int.class
2905                    };
2906            private static final Class<?>[] _updatePriorityParameterTypes67 = new Class[] {
2907                            long.class, boolean.class, long.class, long.class, long.class
2908                    };
2909            private static final Class<?>[] _updatePriorityParameterTypes68 = new Class[] {
2910                            long.class, int.class
2911                    };
2912            private static final Class<?>[] _validateImportLayoutsFileParameterTypes69 = new Class[] {
2913                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2914                            java.io.File.class
2915                    };
2916            private static final Class<?>[] _validateImportLayoutsFileParameterTypes70 = new Class[] {
2917                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2918                            java.io.InputStream.class
2919                    };
2920            private static final Class<?>[] _validateImportLayoutsFileParameterTypes71 = new Class[] {
2921                            long.class, boolean.class, java.util.Map.class, java.io.File.class
2922                    };
2923            private static final Class<?>[] _validateImportLayoutsFileParameterTypes72 = new Class[] {
2924                            long.class, boolean.class, java.util.Map.class,
2925                            java.io.InputStream.class
2926                    };
2927            private static final Class<?>[] _validateImportPortletInfoParameterTypes73 = new Class[] {
2928                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2929                            java.io.File.class
2930                    };
2931            private static final Class<?>[] _validateImportPortletInfoParameterTypes74 = new Class[] {
2932                            com.liferay.portlet.exportimport.model.ExportImportConfiguration.class,
2933                            java.io.InputStream.class
2934                    };
2935            private static final Class<?>[] _validateImportPortletInfoParameterTypes75 = new Class[] {
2936                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2937                            java.io.File.class
2938                    };
2939            private static final Class<?>[] _validateImportPortletInfoParameterTypes76 = new Class[] {
2940                            long.class, long.class, java.lang.String.class, java.util.Map.class,
2941                            java.io.InputStream.class
2942                    };
2943    }