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