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