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.service.LayoutServiceUtil;
023    import com.liferay.portal.kernel.service.http.TunnelUtil;
024    import com.liferay.portal.kernel.util.MethodHandler;
025    import com.liferay.portal.kernel.util.MethodKey;
026    
027    /**
028     * Provides the HTTP utility for the
029     * {@link LayoutServiceUtil} service utility. The
030     * static methods of this class calls the same methods of the service utility.
031     * However, the signatures are different because it requires an additional
032     * {@link HttpPrincipal} parameter.
033     *
034     * <p>
035     * The benefits of using the HTTP utility is that it is fast and allows for
036     * tunneling without the cost of serializing to text. The drawback is that it
037     * only works with Java.
038     * </p>
039     *
040     * <p>
041     * Set the property <b>tunnel.servlet.hosts.allowed</b> in portal.properties to
042     * configure security.
043     * </p>
044     *
045     * <p>
046     * The HTTP utility is only generated for remote services.
047     * </p>
048     *
049     * @author Brian Wing Shun Chan
050     * @see LayoutServiceSoap
051     * @see HttpPrincipal
052     * @see LayoutServiceUtil
053     * @generated
054     */
055    @ProviderType
056    public class LayoutServiceHttp {
057            public static com.liferay.portal.kernel.model.Layout addLayout(
058                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
059                    long parentLayoutId,
060                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
061                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
062                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
063                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
064                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
065                    java.lang.String type, java.lang.String typeSettings, boolean hidden,
066                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
067                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
068                    throws com.liferay.portal.kernel.exception.PortalException {
069                    try {
070                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
071                                            "addLayout", _addLayoutParameterTypes0);
072    
073                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
074                                            privateLayout, parentLayoutId, localeNamesMap,
075                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
076                                            type, typeSettings, hidden, friendlyURLMap, serviceContext);
077    
078                            Object returnObj = null;
079    
080                            try {
081                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
082                            }
083                            catch (Exception e) {
084                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
085                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
086                                    }
087    
088                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
089                            }
090    
091                            return (com.liferay.portal.kernel.model.Layout)returnObj;
092                    }
093                    catch (com.liferay.portal.kernel.exception.SystemException se) {
094                            _log.error(se, se);
095    
096                            throw se;
097                    }
098            }
099    
100            public static com.liferay.portal.kernel.model.Layout addLayout(
101                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
102                    long parentLayoutId, java.lang.String name, java.lang.String title,
103                    java.lang.String description, java.lang.String type, boolean hidden,
104                    java.lang.String friendlyURL,
105                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
106                    throws com.liferay.portal.kernel.exception.PortalException {
107                    try {
108                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
109                                            "addLayout", _addLayoutParameterTypes1);
110    
111                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
112                                            privateLayout, parentLayoutId, name, title, description,
113                                            type, hidden, friendlyURL, serviceContext);
114    
115                            Object returnObj = null;
116    
117                            try {
118                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
119                            }
120                            catch (Exception e) {
121                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
122                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
123                                    }
124    
125                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
126                            }
127    
128                            return (com.liferay.portal.kernel.model.Layout)returnObj;
129                    }
130                    catch (com.liferay.portal.kernel.exception.SystemException se) {
131                            _log.error(se, se);
132    
133                            throw se;
134                    }
135            }
136    
137            public static com.liferay.portal.kernel.repository.model.FileEntry addTempFileEntry(
138                    HttpPrincipal httpPrincipal, long groupId, java.lang.String folderName,
139                    java.lang.String fileName, java.io.InputStream inputStream,
140                    java.lang.String mimeType)
141                    throws com.liferay.portal.kernel.exception.PortalException {
142                    try {
143                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
144                                            "addTempFileEntry", _addTempFileEntryParameterTypes2);
145    
146                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
147                                            folderName, fileName, inputStream, mimeType);
148    
149                            Object returnObj = null;
150    
151                            try {
152                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
153                            }
154                            catch (Exception e) {
155                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
156                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
157                                    }
158    
159                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
160                            }
161    
162                            return (com.liferay.portal.kernel.repository.model.FileEntry)returnObj;
163                    }
164                    catch (com.liferay.portal.kernel.exception.SystemException se) {
165                            _log.error(se, se);
166    
167                            throw se;
168                    }
169            }
170    
171            public static void deleteLayout(HttpPrincipal httpPrincipal, long groupId,
172                    boolean privateLayout, long layoutId,
173                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
174                    throws com.liferay.portal.kernel.exception.PortalException {
175                    try {
176                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
177                                            "deleteLayout", _deleteLayoutParameterTypes3);
178    
179                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
180                                            privateLayout, layoutId, serviceContext);
181    
182                            try {
183                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
184                            }
185                            catch (Exception e) {
186                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
187                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
188                                    }
189    
190                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
191                            }
192                    }
193                    catch (com.liferay.portal.kernel.exception.SystemException se) {
194                            _log.error(se, se);
195    
196                            throw se;
197                    }
198            }
199    
200            public static void deleteLayout(HttpPrincipal httpPrincipal, long plid,
201                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
202                    throws com.liferay.portal.kernel.exception.PortalException {
203                    try {
204                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
205                                            "deleteLayout", _deleteLayoutParameterTypes4);
206    
207                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
208                                            serviceContext);
209    
210                            try {
211                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
212                            }
213                            catch (Exception e) {
214                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
215                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
216                                    }
217    
218                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
219                            }
220                    }
221                    catch (com.liferay.portal.kernel.exception.SystemException se) {
222                            _log.error(se, se);
223    
224                            throw se;
225                    }
226            }
227    
228            public static void deleteTempFileEntry(HttpPrincipal httpPrincipal,
229                    long groupId, java.lang.String folderName, java.lang.String fileName)
230                    throws com.liferay.portal.kernel.exception.PortalException {
231                    try {
232                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
233                                            "deleteTempFileEntry", _deleteTempFileEntryParameterTypes5);
234    
235                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
236                                            folderName, fileName);
237    
238                            try {
239                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
240                            }
241                            catch (Exception e) {
242                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
243                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
244                                    }
245    
246                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
247                            }
248                    }
249                    catch (com.liferay.portal.kernel.exception.SystemException se) {
250                            _log.error(se, se);
251    
252                            throw se;
253                    }
254            }
255    
256            public static byte[] exportLayouts(HttpPrincipal httpPrincipal,
257                    long groupId, boolean privateLayout, long[] layoutIds,
258                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
259                    java.util.Date startDate, java.util.Date endDate)
260                    throws com.liferay.portal.kernel.exception.PortalException {
261                    try {
262                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
263                                            "exportLayouts", _exportLayoutsParameterTypes6);
264    
265                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
266                                            privateLayout, layoutIds, parameterMap, startDate, endDate);
267    
268                            Object returnObj = null;
269    
270                            try {
271                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
272                            }
273                            catch (Exception e) {
274                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
275                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
276                                    }
277    
278                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
279                            }
280    
281                            return (byte[])returnObj;
282                    }
283                    catch (com.liferay.portal.kernel.exception.SystemException se) {
284                            _log.error(se, se);
285    
286                            throw se;
287                    }
288            }
289    
290            public static byte[] exportLayouts(HttpPrincipal httpPrincipal,
291                    long groupId, boolean privateLayout,
292                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
293                    java.util.Date startDate, java.util.Date endDate)
294                    throws com.liferay.portal.kernel.exception.PortalException {
295                    try {
296                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
297                                            "exportLayouts", _exportLayoutsParameterTypes7);
298    
299                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
300                                            privateLayout, parameterMap, startDate, endDate);
301    
302                            Object returnObj = null;
303    
304                            try {
305                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
306                            }
307                            catch (Exception e) {
308                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
309                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
310                                    }
311    
312                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
313                            }
314    
315                            return (byte[])returnObj;
316                    }
317                    catch (com.liferay.portal.kernel.exception.SystemException se) {
318                            _log.error(se, se);
319    
320                            throw se;
321                    }
322            }
323    
324            public static java.io.File exportLayoutsAsFile(
325                    HttpPrincipal httpPrincipal,
326                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration)
327                    throws com.liferay.portal.kernel.exception.PortalException {
328                    try {
329                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
330                                            "exportLayoutsAsFile", _exportLayoutsAsFileParameterTypes8);
331    
332                            MethodHandler methodHandler = new MethodHandler(methodKey,
333                                            exportImportConfiguration);
334    
335                            Object returnObj = null;
336    
337                            try {
338                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
339                            }
340                            catch (Exception e) {
341                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
342                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
343                                    }
344    
345                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
346                            }
347    
348                            return (java.io.File)returnObj;
349                    }
350                    catch (com.liferay.portal.kernel.exception.SystemException se) {
351                            _log.error(se, se);
352    
353                            throw se;
354                    }
355            }
356    
357            public static java.io.File exportLayoutsAsFile(
358                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
359                    long[] layoutIds,
360                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
361                    java.util.Date startDate, java.util.Date endDate)
362                    throws com.liferay.portal.kernel.exception.PortalException {
363                    try {
364                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
365                                            "exportLayoutsAsFile", _exportLayoutsAsFileParameterTypes9);
366    
367                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
368                                            privateLayout, layoutIds, parameterMap, startDate, endDate);
369    
370                            Object returnObj = null;
371    
372                            try {
373                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
374                            }
375                            catch (Exception e) {
376                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
377                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
378                                    }
379    
380                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
381                            }
382    
383                            return (java.io.File)returnObj;
384                    }
385                    catch (com.liferay.portal.kernel.exception.SystemException se) {
386                            _log.error(se, se);
387    
388                            throw se;
389                    }
390            }
391    
392            public static long exportLayoutsAsFileInBackground(
393                    HttpPrincipal httpPrincipal,
394                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration)
395                    throws com.liferay.portal.kernel.exception.PortalException {
396                    try {
397                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
398                                            "exportLayoutsAsFileInBackground",
399                                            _exportLayoutsAsFileInBackgroundParameterTypes10);
400    
401                            MethodHandler methodHandler = new MethodHandler(methodKey,
402                                            exportImportConfiguration);
403    
404                            Object returnObj = null;
405    
406                            try {
407                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
408                            }
409                            catch (Exception e) {
410                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
411                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
412                                    }
413    
414                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
415                            }
416    
417                            return ((Long)returnObj).longValue();
418                    }
419                    catch (com.liferay.portal.kernel.exception.SystemException se) {
420                            _log.error(se, se);
421    
422                            throw se;
423                    }
424            }
425    
426            public static long exportLayoutsAsFileInBackground(
427                    HttpPrincipal httpPrincipal, long exportImportConfigurationId)
428                    throws com.liferay.portal.kernel.exception.PortalException {
429                    try {
430                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
431                                            "exportLayoutsAsFileInBackground",
432                                            _exportLayoutsAsFileInBackgroundParameterTypes11);
433    
434                            MethodHandler methodHandler = new MethodHandler(methodKey,
435                                            exportImportConfigurationId);
436    
437                            Object returnObj = null;
438    
439                            try {
440                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
441                            }
442                            catch (Exception e) {
443                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
444                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
445                                    }
446    
447                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
448                            }
449    
450                            return ((Long)returnObj).longValue();
451                    }
452                    catch (com.liferay.portal.kernel.exception.SystemException se) {
453                            _log.error(se, se);
454    
455                            throw se;
456                    }
457            }
458    
459            public static long exportLayoutsAsFileInBackground(
460                    HttpPrincipal httpPrincipal, java.lang.String taskName, long groupId,
461                    boolean privateLayout, long[] layoutIds,
462                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
463                    java.util.Date startDate, java.util.Date endDate)
464                    throws com.liferay.portal.kernel.exception.PortalException {
465                    try {
466                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
467                                            "exportLayoutsAsFileInBackground",
468                                            _exportLayoutsAsFileInBackgroundParameterTypes12);
469    
470                            MethodHandler methodHandler = new MethodHandler(methodKey,
471                                            taskName, groupId, privateLayout, layoutIds, parameterMap,
472                                            startDate, endDate);
473    
474                            Object returnObj = null;
475    
476                            try {
477                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
478                            }
479                            catch (Exception e) {
480                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
481                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
482                                    }
483    
484                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
485                            }
486    
487                            return ((Long)returnObj).longValue();
488                    }
489                    catch (com.liferay.portal.kernel.exception.SystemException se) {
490                            _log.error(se, se);
491    
492                            throw se;
493                    }
494            }
495    
496            public static long exportLayoutsAsFileInBackground(
497                    HttpPrincipal httpPrincipal, java.lang.String taskName, long groupId,
498                    boolean privateLayout, long[] layoutIds,
499                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
500                    java.util.Date startDate, java.util.Date endDate,
501                    java.lang.String fileName)
502                    throws com.liferay.portal.kernel.exception.PortalException {
503                    try {
504                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
505                                            "exportLayoutsAsFileInBackground",
506                                            _exportLayoutsAsFileInBackgroundParameterTypes13);
507    
508                            MethodHandler methodHandler = new MethodHandler(methodKey,
509                                            taskName, groupId, privateLayout, layoutIds, parameterMap,
510                                            startDate, endDate, fileName);
511    
512                            Object returnObj = null;
513    
514                            try {
515                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
516                            }
517                            catch (Exception e) {
518                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
519                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
520                                    }
521    
522                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
523                            }
524    
525                            return ((Long)returnObj).longValue();
526                    }
527                    catch (com.liferay.portal.kernel.exception.SystemException se) {
528                            _log.error(se, se);
529    
530                            throw se;
531                    }
532            }
533    
534            public static byte[] exportPortletInfo(HttpPrincipal httpPrincipal,
535                    long plid, long groupId, java.lang.String portletId,
536                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
537                    java.util.Date startDate, java.util.Date endDate)
538                    throws com.liferay.portal.kernel.exception.PortalException {
539                    try {
540                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
541                                            "exportPortletInfo", _exportPortletInfoParameterTypes14);
542    
543                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
544                                            groupId, portletId, parameterMap, startDate, endDate);
545    
546                            Object returnObj = null;
547    
548                            try {
549                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
550                            }
551                            catch (Exception e) {
552                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
553                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
554                                    }
555    
556                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
557                            }
558    
559                            return (byte[])returnObj;
560                    }
561                    catch (com.liferay.portal.kernel.exception.SystemException se) {
562                            _log.error(se, se);
563    
564                            throw se;
565                    }
566            }
567    
568            public static byte[] exportPortletInfo(HttpPrincipal httpPrincipal,
569                    long companyId, java.lang.String portletId,
570                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
571                    java.util.Date startDate, java.util.Date endDate)
572                    throws com.liferay.portal.kernel.exception.PortalException {
573                    try {
574                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
575                                            "exportPortletInfo", _exportPortletInfoParameterTypes15);
576    
577                            MethodHandler methodHandler = new MethodHandler(methodKey,
578                                            companyId, portletId, parameterMap, startDate, endDate);
579    
580                            Object returnObj = null;
581    
582                            try {
583                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
584                            }
585                            catch (Exception e) {
586                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
587                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
588                                    }
589    
590                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
591                            }
592    
593                            return (byte[])returnObj;
594                    }
595                    catch (com.liferay.portal.kernel.exception.SystemException se) {
596                            _log.error(se, se);
597    
598                            throw se;
599                    }
600            }
601    
602            public static java.io.File exportPortletInfoAsFile(
603                    HttpPrincipal httpPrincipal,
604                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration)
605                    throws com.liferay.portal.kernel.exception.PortalException {
606                    try {
607                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
608                                            "exportPortletInfoAsFile",
609                                            _exportPortletInfoAsFileParameterTypes16);
610    
611                            MethodHandler methodHandler = new MethodHandler(methodKey,
612                                            exportImportConfiguration);
613    
614                            Object returnObj = null;
615    
616                            try {
617                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
618                            }
619                            catch (Exception e) {
620                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
621                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
622                                    }
623    
624                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
625                            }
626    
627                            return (java.io.File)returnObj;
628                    }
629                    catch (com.liferay.portal.kernel.exception.SystemException se) {
630                            _log.error(se, se);
631    
632                            throw se;
633                    }
634            }
635    
636            public static java.io.File exportPortletInfoAsFile(
637                    HttpPrincipal httpPrincipal, long plid, long groupId,
638                    java.lang.String portletId,
639                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
640                    java.util.Date startDate, java.util.Date endDate)
641                    throws com.liferay.portal.kernel.exception.PortalException {
642                    try {
643                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
644                                            "exportPortletInfoAsFile",
645                                            _exportPortletInfoAsFileParameterTypes17);
646    
647                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
648                                            groupId, portletId, parameterMap, startDate, endDate);
649    
650                            Object returnObj = null;
651    
652                            try {
653                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
654                            }
655                            catch (Exception e) {
656                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
657                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
658                                    }
659    
660                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
661                            }
662    
663                            return (java.io.File)returnObj;
664                    }
665                    catch (com.liferay.portal.kernel.exception.SystemException se) {
666                            _log.error(se, se);
667    
668                            throw se;
669                    }
670            }
671    
672            public static java.io.File exportPortletInfoAsFile(
673                    HttpPrincipal httpPrincipal, java.lang.String portletId,
674                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
675                    java.util.Date startDate, java.util.Date endDate)
676                    throws com.liferay.portal.kernel.exception.PortalException {
677                    try {
678                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
679                                            "exportPortletInfoAsFile",
680                                            _exportPortletInfoAsFileParameterTypes18);
681    
682                            MethodHandler methodHandler = new MethodHandler(methodKey,
683                                            portletId, parameterMap, startDate, endDate);
684    
685                            Object returnObj = null;
686    
687                            try {
688                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
689                            }
690                            catch (Exception e) {
691                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
692                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
693                                    }
694    
695                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
696                            }
697    
698                            return (java.io.File)returnObj;
699                    }
700                    catch (com.liferay.portal.kernel.exception.SystemException se) {
701                            _log.error(se, se);
702    
703                            throw se;
704                    }
705            }
706    
707            public static long exportPortletInfoAsFileInBackground(
708                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
709                    long groupId, java.lang.String portletId,
710                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
711                    java.util.Date startDate, java.util.Date endDate,
712                    java.lang.String fileName)
713                    throws com.liferay.portal.kernel.exception.PortalException {
714                    try {
715                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
716                                            "exportPortletInfoAsFileInBackground",
717                                            _exportPortletInfoAsFileInBackgroundParameterTypes19);
718    
719                            MethodHandler methodHandler = new MethodHandler(methodKey,
720                                            taskName, plid, groupId, portletId, parameterMap,
721                                            startDate, endDate, fileName);
722    
723                            Object returnObj = null;
724    
725                            try {
726                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
727                            }
728                            catch (Exception e) {
729                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
730                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
731                                    }
732    
733                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
734                            }
735    
736                            return ((Long)returnObj).longValue();
737                    }
738                    catch (com.liferay.portal.kernel.exception.SystemException se) {
739                            _log.error(se, se);
740    
741                            throw se;
742                    }
743            }
744    
745            public static long exportPortletInfoAsFileInBackground(
746                    HttpPrincipal httpPrincipal, java.lang.String taskName,
747                    java.lang.String portletId,
748                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
749                    java.util.Date startDate, java.util.Date endDate,
750                    java.lang.String fileName)
751                    throws com.liferay.portal.kernel.exception.PortalException {
752                    try {
753                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
754                                            "exportPortletInfoAsFileInBackground",
755                                            _exportPortletInfoAsFileInBackgroundParameterTypes20);
756    
757                            MethodHandler methodHandler = new MethodHandler(methodKey,
758                                            taskName, portletId, parameterMap, startDate, endDate,
759                                            fileName);
760    
761                            Object returnObj = null;
762    
763                            try {
764                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
765                            }
766                            catch (Exception e) {
767                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
768                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
769                                    }
770    
771                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
772                            }
773    
774                            return ((Long)returnObj).longValue();
775                    }
776                    catch (com.liferay.portal.kernel.exception.SystemException se) {
777                            _log.error(se, se);
778    
779                            throw se;
780                    }
781            }
782    
783            public static java.util.List<com.liferay.portal.kernel.model.Layout> getAncestorLayouts(
784                    HttpPrincipal httpPrincipal, long plid)
785                    throws com.liferay.portal.kernel.exception.PortalException {
786                    try {
787                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
788                                            "getAncestorLayouts", _getAncestorLayoutsParameterTypes21);
789    
790                            MethodHandler methodHandler = new MethodHandler(methodKey, plid);
791    
792                            Object returnObj = null;
793    
794                            try {
795                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
796                            }
797                            catch (Exception e) {
798                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
799                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
800                                    }
801    
802                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
803                            }
804    
805                            return (java.util.List<com.liferay.portal.kernel.model.Layout>)returnObj;
806                    }
807                    catch (com.liferay.portal.kernel.exception.SystemException se) {
808                            _log.error(se, se);
809    
810                            throw se;
811                    }
812            }
813    
814            public static long getDefaultPlid(HttpPrincipal httpPrincipal,
815                    long groupId, long scopeGroupId, boolean privateLayout,
816                    java.lang.String portletId)
817                    throws com.liferay.portal.kernel.exception.PortalException {
818                    try {
819                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
820                                            "getDefaultPlid", _getDefaultPlidParameterTypes22);
821    
822                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
823                                            scopeGroupId, privateLayout, portletId);
824    
825                            Object returnObj = null;
826    
827                            try {
828                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
829                            }
830                            catch (Exception e) {
831                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
832                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
833                                    }
834    
835                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
836                            }
837    
838                            return ((Long)returnObj).longValue();
839                    }
840                    catch (com.liferay.portal.kernel.exception.SystemException se) {
841                            _log.error(se, se);
842    
843                            throw se;
844                    }
845            }
846    
847            public static long getDefaultPlid(HttpPrincipal httpPrincipal,
848                    long groupId, long scopeGroupId, java.lang.String portletId)
849                    throws com.liferay.portal.kernel.exception.PortalException {
850                    try {
851                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
852                                            "getDefaultPlid", _getDefaultPlidParameterTypes23);
853    
854                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
855                                            scopeGroupId, portletId);
856    
857                            Object returnObj = null;
858    
859                            try {
860                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
861                            }
862                            catch (Exception e) {
863                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
864                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
865                                    }
866    
867                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
868                            }
869    
870                            return ((Long)returnObj).longValue();
871                    }
872                    catch (com.liferay.portal.kernel.exception.SystemException se) {
873                            _log.error(se, se);
874    
875                            throw se;
876                    }
877            }
878    
879            public static com.liferay.portal.kernel.model.Layout getLayoutByUuidAndGroupId(
880                    HttpPrincipal httpPrincipal, java.lang.String uuid, long groupId,
881                    boolean privateLayout)
882                    throws com.liferay.portal.kernel.exception.PortalException {
883                    try {
884                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
885                                            "getLayoutByUuidAndGroupId",
886                                            _getLayoutByUuidAndGroupIdParameterTypes24);
887    
888                            MethodHandler methodHandler = new MethodHandler(methodKey, uuid,
889                                            groupId, privateLayout);
890    
891                            Object returnObj = null;
892    
893                            try {
894                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
895                            }
896                            catch (Exception e) {
897                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
898                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
899                                    }
900    
901                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
902                            }
903    
904                            return (com.liferay.portal.kernel.model.Layout)returnObj;
905                    }
906                    catch (com.liferay.portal.kernel.exception.SystemException se) {
907                            _log.error(se, se);
908    
909                            throw se;
910                    }
911            }
912    
913            public static java.lang.String getLayoutName(HttpPrincipal httpPrincipal,
914                    long groupId, boolean privateLayout, long layoutId,
915                    java.lang.String languageId)
916                    throws com.liferay.portal.kernel.exception.PortalException {
917                    try {
918                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
919                                            "getLayoutName", _getLayoutNameParameterTypes25);
920    
921                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
922                                            privateLayout, layoutId, languageId);
923    
924                            Object returnObj = null;
925    
926                            try {
927                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
928                            }
929                            catch (Exception e) {
930                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
931                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
932                                    }
933    
934                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
935                            }
936    
937                            return (java.lang.String)returnObj;
938                    }
939                    catch (com.liferay.portal.kernel.exception.SystemException se) {
940                            _log.error(se, se);
941    
942                            throw se;
943                    }
944            }
945    
946            public static com.liferay.portal.kernel.model.LayoutReference[] getLayoutReferences(
947                    HttpPrincipal httpPrincipal, long companyId,
948                    java.lang.String portletId, java.lang.String preferencesKey,
949                    java.lang.String preferencesValue) {
950                    try {
951                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
952                                            "getLayoutReferences", _getLayoutReferencesParameterTypes26);
953    
954                            MethodHandler methodHandler = new MethodHandler(methodKey,
955                                            companyId, portletId, preferencesKey, preferencesValue);
956    
957                            Object returnObj = null;
958    
959                            try {
960                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
961                            }
962                            catch (Exception e) {
963                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
964                            }
965    
966                            return (com.liferay.portal.kernel.model.LayoutReference[])returnObj;
967                    }
968                    catch (com.liferay.portal.kernel.exception.SystemException se) {
969                            _log.error(se, se);
970    
971                            throw se;
972                    }
973            }
974    
975            public static java.util.List<com.liferay.portal.kernel.model.Layout> getLayouts(
976                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout) {
977                    try {
978                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
979                                            "getLayouts", _getLayoutsParameterTypes27);
980    
981                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
982                                            privateLayout);
983    
984                            Object returnObj = null;
985    
986                            try {
987                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
988                            }
989                            catch (Exception e) {
990                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
991                            }
992    
993                            return (java.util.List<com.liferay.portal.kernel.model.Layout>)returnObj;
994                    }
995                    catch (com.liferay.portal.kernel.exception.SystemException se) {
996                            _log.error(se, se);
997    
998                            throw se;
999                    }
1000            }
1001    
1002            public static java.util.List<com.liferay.portal.kernel.model.Layout> getLayouts(
1003                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1004                    long parentLayoutId)
1005                    throws com.liferay.portal.kernel.exception.PortalException {
1006                    try {
1007                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1008                                            "getLayouts", _getLayoutsParameterTypes28);
1009    
1010                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1011                                            privateLayout, parentLayoutId);
1012    
1013                            Object returnObj = null;
1014    
1015                            try {
1016                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1017                            }
1018                            catch (Exception e) {
1019                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1020                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1021                                    }
1022    
1023                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1024                            }
1025    
1026                            return (java.util.List<com.liferay.portal.kernel.model.Layout>)returnObj;
1027                    }
1028                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1029                            _log.error(se, se);
1030    
1031                            throw se;
1032                    }
1033            }
1034    
1035            public static java.util.List<com.liferay.portal.kernel.model.Layout> getLayouts(
1036                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1037                    long parentLayoutId, boolean incomplete, int start, int end)
1038                    throws com.liferay.portal.kernel.exception.PortalException {
1039                    try {
1040                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1041                                            "getLayouts", _getLayoutsParameterTypes29);
1042    
1043                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1044                                            privateLayout, parentLayoutId, incomplete, start, end);
1045    
1046                            Object returnObj = null;
1047    
1048                            try {
1049                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1050                            }
1051                            catch (Exception e) {
1052                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1053                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1054                                    }
1055    
1056                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1057                            }
1058    
1059                            return (java.util.List<com.liferay.portal.kernel.model.Layout>)returnObj;
1060                    }
1061                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1062                            _log.error(se, se);
1063    
1064                            throw se;
1065                    }
1066            }
1067    
1068            public static int getLayoutsCount(HttpPrincipal httpPrincipal,
1069                    long groupId, boolean privateLayout, long parentLayoutId) {
1070                    try {
1071                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1072                                            "getLayoutsCount", _getLayoutsCountParameterTypes30);
1073    
1074                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1075                                            privateLayout, parentLayoutId);
1076    
1077                            Object returnObj = null;
1078    
1079                            try {
1080                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1081                            }
1082                            catch (Exception e) {
1083                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1084                            }
1085    
1086                            return ((Integer)returnObj).intValue();
1087                    }
1088                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1089                            _log.error(se, se);
1090    
1091                            throw se;
1092                    }
1093            }
1094    
1095            public static java.lang.String[] getTempFileNames(
1096                    HttpPrincipal httpPrincipal, long groupId, java.lang.String folderName)
1097                    throws com.liferay.portal.kernel.exception.PortalException {
1098                    try {
1099                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1100                                            "getTempFileNames", _getTempFileNamesParameterTypes31);
1101    
1102                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1103                                            folderName);
1104    
1105                            Object returnObj = null;
1106    
1107                            try {
1108                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1109                            }
1110                            catch (Exception e) {
1111                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1112                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1113                                    }
1114    
1115                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1116                            }
1117    
1118                            return (java.lang.String[])returnObj;
1119                    }
1120                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1121                            _log.error(se, se);
1122    
1123                            throw se;
1124                    }
1125            }
1126    
1127            public static void importLayouts(HttpPrincipal httpPrincipal,
1128                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration,
1129                    java.io.File file)
1130                    throws com.liferay.portal.kernel.exception.PortalException {
1131                    try {
1132                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1133                                            "importLayouts", _importLayoutsParameterTypes32);
1134    
1135                            MethodHandler methodHandler = new MethodHandler(methodKey,
1136                                            exportImportConfiguration, file);
1137    
1138                            try {
1139                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1140                            }
1141                            catch (Exception e) {
1142                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1143                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1144                                    }
1145    
1146                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1147                            }
1148                    }
1149                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1150                            _log.error(se, se);
1151    
1152                            throw se;
1153                    }
1154            }
1155    
1156            public static void importLayouts(HttpPrincipal httpPrincipal,
1157                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration,
1158                    java.io.InputStream is)
1159                    throws com.liferay.portal.kernel.exception.PortalException {
1160                    try {
1161                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1162                                            "importLayouts", _importLayoutsParameterTypes33);
1163    
1164                            MethodHandler methodHandler = new MethodHandler(methodKey,
1165                                            exportImportConfiguration, is);
1166    
1167                            try {
1168                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1169                            }
1170                            catch (Exception e) {
1171                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1172                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1173                                    }
1174    
1175                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1176                            }
1177                    }
1178                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1179                            _log.error(se, se);
1180    
1181                            throw se;
1182                    }
1183            }
1184    
1185            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1186                    boolean privateLayout,
1187                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1188                    byte[] bytes)
1189                    throws com.liferay.portal.kernel.exception.PortalException {
1190                    try {
1191                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1192                                            "importLayouts", _importLayoutsParameterTypes34);
1193    
1194                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1195                                            privateLayout, parameterMap, bytes);
1196    
1197                            try {
1198                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1199                            }
1200                            catch (Exception e) {
1201                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1202                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1203                                    }
1204    
1205                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1206                            }
1207                    }
1208                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1209                            _log.error(se, se);
1210    
1211                            throw se;
1212                    }
1213            }
1214    
1215            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1216                    boolean privateLayout,
1217                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1218                    java.io.File file)
1219                    throws com.liferay.portal.kernel.exception.PortalException {
1220                    try {
1221                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1222                                            "importLayouts", _importLayoutsParameterTypes35);
1223    
1224                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1225                                            privateLayout, parameterMap, file);
1226    
1227                            try {
1228                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1229                            }
1230                            catch (Exception e) {
1231                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1232                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1233                                    }
1234    
1235                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1236                            }
1237                    }
1238                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1239                            _log.error(se, se);
1240    
1241                            throw se;
1242                    }
1243            }
1244    
1245            public static void importLayouts(HttpPrincipal httpPrincipal, long groupId,
1246                    boolean privateLayout,
1247                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1248                    java.io.InputStream is)
1249                    throws com.liferay.portal.kernel.exception.PortalException {
1250                    try {
1251                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1252                                            "importLayouts", _importLayoutsParameterTypes36);
1253    
1254                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1255                                            privateLayout, parameterMap, is);
1256    
1257                            try {
1258                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1259                            }
1260                            catch (Exception e) {
1261                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1262                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1263                                    }
1264    
1265                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1266                            }
1267                    }
1268                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1269                            _log.error(se, se);
1270    
1271                            throw se;
1272                    }
1273            }
1274    
1275            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1276                    java.lang.String taskName, long groupId, boolean privateLayout,
1277                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1278                    java.io.File file)
1279                    throws com.liferay.portal.kernel.exception.PortalException {
1280                    try {
1281                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1282                                            "importLayoutsInBackground",
1283                                            _importLayoutsInBackgroundParameterTypes37);
1284    
1285                            MethodHandler methodHandler = new MethodHandler(methodKey,
1286                                            taskName, groupId, privateLayout, parameterMap, file);
1287    
1288                            Object returnObj = null;
1289    
1290                            try {
1291                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1292                            }
1293                            catch (Exception e) {
1294                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1295                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1296                                    }
1297    
1298                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1299                            }
1300    
1301                            return ((Long)returnObj).longValue();
1302                    }
1303                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1304                            _log.error(se, se);
1305    
1306                            throw se;
1307                    }
1308            }
1309    
1310            public static long importLayoutsInBackground(HttpPrincipal httpPrincipal,
1311                    java.lang.String taskName, long groupId, boolean privateLayout,
1312                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1313                    java.io.InputStream inputStream)
1314                    throws com.liferay.portal.kernel.exception.PortalException {
1315                    try {
1316                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1317                                            "importLayoutsInBackground",
1318                                            _importLayoutsInBackgroundParameterTypes38);
1319    
1320                            MethodHandler methodHandler = new MethodHandler(methodKey,
1321                                            taskName, groupId, privateLayout, parameterMap, inputStream);
1322    
1323                            Object returnObj = null;
1324    
1325                            try {
1326                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1327                            }
1328                            catch (Exception e) {
1329                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1330                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1331                                    }
1332    
1333                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1334                            }
1335    
1336                            return ((Long)returnObj).longValue();
1337                    }
1338                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1339                            _log.error(se, se);
1340    
1341                            throw se;
1342                    }
1343            }
1344    
1345            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1346                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration,
1347                    java.io.File file)
1348                    throws com.liferay.portal.kernel.exception.PortalException {
1349                    try {
1350                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1351                                            "importPortletInfo", _importPortletInfoParameterTypes39);
1352    
1353                            MethodHandler methodHandler = new MethodHandler(methodKey,
1354                                            exportImportConfiguration, file);
1355    
1356                            try {
1357                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1358                            }
1359                            catch (Exception e) {
1360                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1361                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1362                                    }
1363    
1364                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1365                            }
1366                    }
1367                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1368                            _log.error(se, se);
1369    
1370                            throw se;
1371                    }
1372            }
1373    
1374            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1375                    com.liferay.exportimport.kernel.model.ExportImportConfiguration exportImportConfiguration,
1376                    java.io.InputStream is)
1377                    throws com.liferay.portal.kernel.exception.PortalException {
1378                    try {
1379                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1380                                            "importPortletInfo", _importPortletInfoParameterTypes40);
1381    
1382                            MethodHandler methodHandler = new MethodHandler(methodKey,
1383                                            exportImportConfiguration, is);
1384    
1385                            try {
1386                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1387                            }
1388                            catch (Exception e) {
1389                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1390                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1391                                    }
1392    
1393                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1394                            }
1395                    }
1396                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1397                            _log.error(se, se);
1398    
1399                            throw se;
1400                    }
1401            }
1402    
1403            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1404                    long plid, long groupId, java.lang.String portletId,
1405                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1406                    java.io.File file)
1407                    throws com.liferay.portal.kernel.exception.PortalException {
1408                    try {
1409                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1410                                            "importPortletInfo", _importPortletInfoParameterTypes41);
1411    
1412                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1413                                            groupId, portletId, parameterMap, file);
1414    
1415                            try {
1416                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1417                            }
1418                            catch (Exception e) {
1419                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1420                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1421                                    }
1422    
1423                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1424                            }
1425                    }
1426                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1427                            _log.error(se, se);
1428    
1429                            throw se;
1430                    }
1431            }
1432    
1433            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1434                    long plid, long groupId, java.lang.String portletId,
1435                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1436                    java.io.InputStream is)
1437                    throws com.liferay.portal.kernel.exception.PortalException {
1438                    try {
1439                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1440                                            "importPortletInfo", _importPortletInfoParameterTypes42);
1441    
1442                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1443                                            groupId, portletId, parameterMap, is);
1444    
1445                            try {
1446                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1447                            }
1448                            catch (Exception e) {
1449                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1450                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1451                                    }
1452    
1453                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1454                            }
1455                    }
1456                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1457                            _log.error(se, se);
1458    
1459                            throw se;
1460                    }
1461            }
1462    
1463            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1464                    java.lang.String portletId,
1465                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1466                    java.io.File file)
1467                    throws com.liferay.portal.kernel.exception.PortalException {
1468                    try {
1469                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1470                                            "importPortletInfo", _importPortletInfoParameterTypes43);
1471    
1472                            MethodHandler methodHandler = new MethodHandler(methodKey,
1473                                            portletId, parameterMap, file);
1474    
1475                            try {
1476                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1477                            }
1478                            catch (Exception e) {
1479                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1480                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1481                                    }
1482    
1483                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1484                            }
1485                    }
1486                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1487                            _log.error(se, se);
1488    
1489                            throw se;
1490                    }
1491            }
1492    
1493            public static void importPortletInfo(HttpPrincipal httpPrincipal,
1494                    java.lang.String portletId,
1495                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1496                    java.io.InputStream is)
1497                    throws com.liferay.portal.kernel.exception.PortalException {
1498                    try {
1499                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1500                                            "importPortletInfo", _importPortletInfoParameterTypes44);
1501    
1502                            MethodHandler methodHandler = new MethodHandler(methodKey,
1503                                            portletId, parameterMap, is);
1504    
1505                            try {
1506                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1507                            }
1508                            catch (Exception e) {
1509                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1510                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1511                                    }
1512    
1513                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1514                            }
1515                    }
1516                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1517                            _log.error(se, se);
1518    
1519                            throw se;
1520                    }
1521            }
1522    
1523            public static long importPortletInfoInBackground(
1524                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1525                    long groupId, java.lang.String portletId,
1526                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1527                    java.io.File file)
1528                    throws com.liferay.portal.kernel.exception.PortalException {
1529                    try {
1530                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1531                                            "importPortletInfoInBackground",
1532                                            _importPortletInfoInBackgroundParameterTypes45);
1533    
1534                            MethodHandler methodHandler = new MethodHandler(methodKey,
1535                                            taskName, plid, groupId, portletId, parameterMap, file);
1536    
1537                            Object returnObj = null;
1538    
1539                            try {
1540                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1541                            }
1542                            catch (Exception e) {
1543                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1544                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1545                                    }
1546    
1547                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1548                            }
1549    
1550                            return ((Long)returnObj).longValue();
1551                    }
1552                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1553                            _log.error(se, se);
1554    
1555                            throw se;
1556                    }
1557            }
1558    
1559            public static long importPortletInfoInBackground(
1560                    HttpPrincipal httpPrincipal, java.lang.String taskName, long plid,
1561                    long groupId, java.lang.String portletId,
1562                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1563                    java.io.InputStream is)
1564                    throws com.liferay.portal.kernel.exception.PortalException {
1565                    try {
1566                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1567                                            "importPortletInfoInBackground",
1568                                            _importPortletInfoInBackgroundParameterTypes46);
1569    
1570                            MethodHandler methodHandler = new MethodHandler(methodKey,
1571                                            taskName, plid, groupId, portletId, parameterMap, is);
1572    
1573                            Object returnObj = null;
1574    
1575                            try {
1576                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1577                            }
1578                            catch (Exception e) {
1579                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1580                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1581                                    }
1582    
1583                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1584                            }
1585    
1586                            return ((Long)returnObj).longValue();
1587                    }
1588                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1589                            _log.error(se, se);
1590    
1591                            throw se;
1592                    }
1593            }
1594    
1595            public static void importPortletInfoInBackground(
1596                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1597                    java.lang.String portletId,
1598                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1599                    java.io.File file)
1600                    throws com.liferay.portal.kernel.exception.PortalException {
1601                    try {
1602                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1603                                            "importPortletInfoInBackground",
1604                                            _importPortletInfoInBackgroundParameterTypes47);
1605    
1606                            MethodHandler methodHandler = new MethodHandler(methodKey,
1607                                            taskName, portletId, parameterMap, file);
1608    
1609                            try {
1610                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1611                            }
1612                            catch (Exception e) {
1613                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1614                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1615                                    }
1616    
1617                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1618                            }
1619                    }
1620                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1621                            _log.error(se, se);
1622    
1623                            throw se;
1624                    }
1625            }
1626    
1627            public static void importPortletInfoInBackground(
1628                    HttpPrincipal httpPrincipal, java.lang.String taskName,
1629                    java.lang.String portletId,
1630                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1631                    java.io.InputStream is)
1632                    throws com.liferay.portal.kernel.exception.PortalException {
1633                    try {
1634                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1635                                            "importPortletInfoInBackground",
1636                                            _importPortletInfoInBackgroundParameterTypes48);
1637    
1638                            MethodHandler methodHandler = new MethodHandler(methodKey,
1639                                            taskName, portletId, parameterMap, is);
1640    
1641                            try {
1642                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1643                            }
1644                            catch (Exception e) {
1645                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1646                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1647                                    }
1648    
1649                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1650                            }
1651                    }
1652                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1653                            _log.error(se, se);
1654    
1655                            throw se;
1656                    }
1657            }
1658    
1659            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1660                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1661                    long[] layoutIds,
1662                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1663                    java.lang.String scope, java.util.Date startDate,
1664                    java.util.Date endDate, java.lang.String groupName,
1665                    java.lang.String cronText, java.util.Date schedulerStartDate,
1666                    java.util.Date schedulerEndDate, java.lang.String description)
1667                    throws com.liferay.portal.kernel.exception.PortalException {
1668                    try {
1669                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1670                                            "schedulePublishToLive",
1671                                            _schedulePublishToLiveParameterTypes49);
1672    
1673                            MethodHandler methodHandler = new MethodHandler(methodKey,
1674                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1675                                            parameterMap, scope, startDate, endDate, groupName,
1676                                            cronText, schedulerStartDate, schedulerEndDate, description);
1677    
1678                            try {
1679                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1680                            }
1681                            catch (Exception e) {
1682                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1683                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1684                                    }
1685    
1686                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1687                            }
1688                    }
1689                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1690                            _log.error(se, se);
1691    
1692                            throw se;
1693                    }
1694            }
1695    
1696            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1697                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1698                    long[] layoutIds,
1699                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1700                    java.lang.String groupName, java.lang.String cronText,
1701                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1702                    java.lang.String description)
1703                    throws com.liferay.portal.kernel.exception.PortalException {
1704                    try {
1705                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1706                                            "schedulePublishToLive",
1707                                            _schedulePublishToLiveParameterTypes50);
1708    
1709                            MethodHandler methodHandler = new MethodHandler(methodKey,
1710                                            sourceGroupId, targetGroupId, privateLayout, layoutIds,
1711                                            parameterMap, groupName, cronText, schedulerStartDate,
1712                                            schedulerEndDate, description);
1713    
1714                            try {
1715                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1716                            }
1717                            catch (Exception e) {
1718                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1719                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1720                                    }
1721    
1722                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1723                            }
1724                    }
1725                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1726                            _log.error(se, se);
1727    
1728                            throw se;
1729                    }
1730            }
1731    
1732            public static void schedulePublishToLive(HttpPrincipal httpPrincipal,
1733                    long sourceGroupId, long targetGroupId, boolean privateLayout,
1734                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1735                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1736                    java.lang.String scope, java.util.Date startDate,
1737                    java.util.Date endDate, java.lang.String groupName,
1738                    java.lang.String cronText, java.util.Date schedulerStartDate,
1739                    java.util.Date schedulerEndDate, java.lang.String description)
1740                    throws com.liferay.portal.kernel.exception.PortalException {
1741                    try {
1742                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1743                                            "schedulePublishToLive",
1744                                            _schedulePublishToLiveParameterTypes51);
1745    
1746                            MethodHandler methodHandler = new MethodHandler(methodKey,
1747                                            sourceGroupId, targetGroupId, privateLayout, layoutIdMap,
1748                                            parameterMap, scope, startDate, endDate, groupName,
1749                                            cronText, schedulerStartDate, schedulerEndDate, description);
1750    
1751                            try {
1752                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1753                            }
1754                            catch (Exception e) {
1755                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1756                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1757                                    }
1758    
1759                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1760                            }
1761                    }
1762                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1763                            _log.error(se, se);
1764    
1765                            throw se;
1766                    }
1767            }
1768    
1769            public static void schedulePublishToRemote(HttpPrincipal httpPrincipal,
1770                    long sourceGroupId, boolean privateLayout,
1771                    java.util.Map<java.lang.Long, java.lang.Boolean> layoutIdMap,
1772                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1773                    java.lang.String remoteAddress, int remotePort,
1774                    java.lang.String remotePathContext, boolean secureConnection,
1775                    long remoteGroupId, boolean remotePrivateLayout,
1776                    java.util.Date startDate, java.util.Date endDate,
1777                    java.lang.String groupName, java.lang.String cronText,
1778                    java.util.Date schedulerStartDate, java.util.Date schedulerEndDate,
1779                    java.lang.String description)
1780                    throws com.liferay.portal.kernel.exception.PortalException {
1781                    try {
1782                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1783                                            "schedulePublishToRemote",
1784                                            _schedulePublishToRemoteParameterTypes52);
1785    
1786                            MethodHandler methodHandler = new MethodHandler(methodKey,
1787                                            sourceGroupId, privateLayout, layoutIdMap, parameterMap,
1788                                            remoteAddress, remotePort, remotePathContext,
1789                                            secureConnection, remoteGroupId, remotePrivateLayout,
1790                                            startDate, endDate, groupName, cronText,
1791                                            schedulerStartDate, schedulerEndDate, description);
1792    
1793                            try {
1794                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1795                            }
1796                            catch (Exception e) {
1797                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1798                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1799                                    }
1800    
1801                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1802                            }
1803                    }
1804                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1805                            _log.error(se, se);
1806    
1807                            throw se;
1808                    }
1809            }
1810    
1811            public static void setLayouts(HttpPrincipal httpPrincipal, long groupId,
1812                    boolean privateLayout, long parentLayoutId, long[] layoutIds,
1813                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1814                    throws com.liferay.portal.kernel.exception.PortalException {
1815                    try {
1816                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1817                                            "setLayouts", _setLayoutsParameterTypes53);
1818    
1819                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1820                                            privateLayout, parentLayoutId, layoutIds, serviceContext);
1821    
1822                            try {
1823                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1824                            }
1825                            catch (Exception e) {
1826                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1827                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1828                                    }
1829    
1830                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1831                            }
1832                    }
1833                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1834                            _log.error(se, se);
1835    
1836                            throw se;
1837                    }
1838            }
1839    
1840            public static void unschedulePublishToLive(HttpPrincipal httpPrincipal,
1841                    long groupId, java.lang.String jobName, java.lang.String groupName)
1842                    throws com.liferay.portal.kernel.exception.PortalException {
1843                    try {
1844                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1845                                            "unschedulePublishToLive",
1846                                            _unschedulePublishToLiveParameterTypes54);
1847    
1848                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1849                                            jobName, groupName);
1850    
1851                            try {
1852                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1853                            }
1854                            catch (Exception e) {
1855                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1856                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1857                                    }
1858    
1859                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1860                            }
1861                    }
1862                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1863                            _log.error(se, se);
1864    
1865                            throw se;
1866                    }
1867            }
1868    
1869            public static void unschedulePublishToRemote(HttpPrincipal httpPrincipal,
1870                    long groupId, java.lang.String jobName, java.lang.String groupName)
1871                    throws com.liferay.portal.kernel.exception.PortalException {
1872                    try {
1873                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1874                                            "unschedulePublishToRemote",
1875                                            _unschedulePublishToRemoteParameterTypes55);
1876    
1877                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1878                                            jobName, groupName);
1879    
1880                            try {
1881                                    TunnelUtil.invoke(httpPrincipal, methodHandler);
1882                            }
1883                            catch (Exception e) {
1884                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1885                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1886                                    }
1887    
1888                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1889                            }
1890                    }
1891                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1892                            _log.error(se, se);
1893    
1894                            throw se;
1895                    }
1896            }
1897    
1898            public static com.liferay.portal.kernel.model.Layout updateIconImage(
1899                    HttpPrincipal httpPrincipal, long plid, byte[] bytes)
1900                    throws com.liferay.portal.kernel.exception.PortalException {
1901                    try {
1902                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1903                                            "updateIconImage", _updateIconImageParameterTypes56);
1904    
1905                            MethodHandler methodHandler = new MethodHandler(methodKey, plid,
1906                                            bytes);
1907    
1908                            Object returnObj = null;
1909    
1910                            try {
1911                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1912                            }
1913                            catch (Exception e) {
1914                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1915                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1916                                    }
1917    
1918                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1919                            }
1920    
1921                            return (com.liferay.portal.kernel.model.Layout)returnObj;
1922                    }
1923                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1924                            _log.error(se, se);
1925    
1926                            throw se;
1927                    }
1928            }
1929    
1930            public static com.liferay.portal.kernel.model.Layout updateLayout(
1931                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1932                    long layoutId, long parentLayoutId,
1933                    java.util.Map<java.util.Locale, java.lang.String> localeNamesMap,
1934                    java.util.Map<java.util.Locale, java.lang.String> localeTitlesMap,
1935                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1936                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1937                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1938                    java.lang.String type, boolean hidden,
1939                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
1940                    boolean iconImage, byte[] iconBytes,
1941                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1942                    throws com.liferay.portal.kernel.exception.PortalException {
1943                    try {
1944                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1945                                            "updateLayout", _updateLayoutParameterTypes57);
1946    
1947                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1948                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
1949                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
1950                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
1951                                            serviceContext);
1952    
1953                            Object returnObj = null;
1954    
1955                            try {
1956                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1957                            }
1958                            catch (Exception e) {
1959                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1960                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1961                                    }
1962    
1963                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1964                            }
1965    
1966                            return (com.liferay.portal.kernel.model.Layout)returnObj;
1967                    }
1968                    catch (com.liferay.portal.kernel.exception.SystemException se) {
1969                            _log.error(se, se);
1970    
1971                            throw se;
1972                    }
1973            }
1974    
1975            public static com.liferay.portal.kernel.model.Layout updateLayout(
1976                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
1977                    long layoutId, java.lang.String typeSettings)
1978                    throws com.liferay.portal.kernel.exception.PortalException {
1979                    try {
1980                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
1981                                            "updateLayout", _updateLayoutParameterTypes58);
1982    
1983                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
1984                                            privateLayout, layoutId, typeSettings);
1985    
1986                            Object returnObj = null;
1987    
1988                            try {
1989                                    returnObj = TunnelUtil.invoke(httpPrincipal, methodHandler);
1990                            }
1991                            catch (Exception e) {
1992                                    if (e instanceof com.liferay.portal.kernel.exception.PortalException) {
1993                                            throw (com.liferay.portal.kernel.exception.PortalException)e;
1994                                    }
1995    
1996                                    throw new com.liferay.portal.kernel.exception.SystemException(e);
1997                            }
1998    
1999                            return (com.liferay.portal.kernel.model.Layout)returnObj;
2000                    }
2001                    catch (com.liferay.portal.kernel.exception.SystemException se) {
2002                            _log.error(se, se);
2003    
2004                            throw se;
2005                    }
2006            }
2007    
2008            public static com.liferay.portal.kernel.model.Layout updateLookAndFeel(
2009                    HttpPrincipal httpPrincipal, long groupId, boolean privateLayout,
2010                    long layoutId, java.lang.String themeId,
2011                    java.lang.String colorSchemeId, java.lang.String css)
2012                    throws com.liferay.portal.kernel.exception.PortalException {
2013                    try {
2014                            MethodKey methodKey = new MethodKey(LayoutServiceUtil.class,
2015                                            "updateLookAndFeel", _updateLookAndFeelParameterTypes59);
2016    
2017                            MethodHandler methodHandler = new MethodHandler(methodKey, groupId,
2018                                            privateLayout, layoutId, themeId, colorSchemeId, css);
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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.exportimport.kernel.lar.MissingReferences validateImportLayoutsFile(
2307                    HttpPrincipal httpPrincipal,
2308                    com.liferay.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.lar.MissingReferences validateImportLayoutsFile(
2342                    HttpPrincipal httpPrincipal,
2343                    com.liferay.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.lar.MissingReferences validateImportPortletInfo(
2447                    HttpPrincipal httpPrincipal,
2448                    com.liferay.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.lar.MissingReferences validateImportPortletInfo(
2482                    HttpPrincipal httpPrincipal,
2483                    com.liferay.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.kernel.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.kernel.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.kernel.service.ServiceContext.class
2609                    };
2610            private static final Class<?>[] _deleteLayoutParameterTypes4 = new Class[] {
2611                            long.class, com.liferay.portal.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.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.exportimport.kernel.model.ExportImportConfiguration.class,
2715                            java.io.File.class
2716                    };
2717            private static final Class<?>[] _importLayoutsParameterTypes33 = new Class[] {
2718                            com.liferay.exportimport.kernel.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.exportimport.kernel.model.ExportImportConfiguration.class,
2741                            java.io.File.class
2742                    };
2743            private static final Class<?>[] _importPortletInfoParameterTypes40 = new Class[] {
2744                            com.liferay.exportimport.kernel.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.kernel.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.kernel.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
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.exportimport.kernel.model.ExportImportConfiguration.class,
2860                            java.io.File.class
2861                    };
2862            private static final Class<?>[] _validateImportLayoutsFileParameterTypes69 = new Class[] {
2863                            com.liferay.exportimport.kernel.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.exportimport.kernel.model.ExportImportConfiguration.class,
2875                            java.io.File.class
2876                    };
2877            private static final Class<?>[] _validateImportPortletInfoParameterTypes73 = new Class[] {
2878                            com.liferay.exportimport.kernel.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    }