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.service.LayoutServiceUtil;
022    import com.liferay.portal.kernel.util.LocalizationUtil;
023    
024    import java.rmi.RemoteException;
025    
026    import java.util.Locale;
027    import java.util.Map;
028    
029    /**
030     * Provides the SOAP utility for the
031     * {@link LayoutServiceUtil} service utility. The
032     * static methods of this class calls the same methods of the service utility.
033     * However, the signatures are different because it is difficult for SOAP to
034     * support certain types.
035     *
036     * <p>
037     * ServiceBuilder follows certain rules in translating the methods. For example,
038     * if the method in the service utility returns a {@link java.util.List}, that
039     * is translated to an array of {@link com.liferay.portal.kernel.model.LayoutSoap}.
040     * If the method in the service utility returns a
041     * {@link com.liferay.portal.kernel.model.Layout}, that is translated to a
042     * {@link com.liferay.portal.kernel.model.LayoutSoap}. Methods that SOAP cannot
043     * safely wire are skipped.
044     * </p>
045     *
046     * <p>
047     * The benefits of using the SOAP utility is that it is cross platform
048     * compatible. SOAP allows different languages like Java, .NET, C++, PHP, and
049     * even Perl, to call the generated services. One drawback of SOAP is that it is
050     * slow because it needs to serialize all calls into a text format (XML).
051     * </p>
052     *
053     * <p>
054     * You can see a list of services at http://localhost:8080/api/axis. Set the
055     * property <b>axis.servlet.hosts.allowed</b> in portal.properties to configure
056     * security.
057     * </p>
058     *
059     * <p>
060     * The SOAP utility is only generated for remote services.
061     * </p>
062     *
063     * @author Brian Wing Shun Chan
064     * @see LayoutServiceHttp
065     * @see com.liferay.portal.kernel.model.LayoutSoap
066     * @see LayoutServiceUtil
067     * @generated
068     */
069    @ProviderType
070    public class LayoutServiceSoap {
071            /**
072            * Adds a layout with additional parameters.
073            *
074            * <p>
075            * This method handles the creation of the layout including its resources,
076            * metadata, and internal data structures. It is not necessary to make
077            * subsequent calls to any methods to setup default groups, resources, ...
078            * etc.
079            * </p>
080            *
081            * @param groupId the primary key of the group
082            * @param privateLayout whether the layout is private to the group
083            * @param parentLayoutId the primary key of the parent layout (optionally
084            {@link LayoutConstants#DEFAULT_PARENT_LAYOUT_ID})
085            * @param localeNamesMap the layout's locales and localized names
086            * @param localeTitlesMap the layout's locales and localized titles
087            * @param descriptionMap the layout's locales and localized descriptions
088            * @param keywordsMap the layout's locales and localized keywords
089            * @param robotsMap the layout's locales and localized robots
090            * @param type the layout's type (optionally {@link
091            LayoutConstants#TYPE_PORTLET}). The possible types can be found
092            in {@link LayoutConstants}.
093            * @param typeSettings the settings to load the unicode properties object.
094            See {@link com.liferay.portal.kernel.util.UnicodeProperties
095            #fastLoad(String)}.
096            * @param hidden whether the layout is hidden
097            * @param friendlyURLMap the layout's locales and localized friendly URLs.
098            To see how the URL is normalized when accessed, see {@link
099            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
100            String)}.
101            * @param serviceContext the service context to be applied. Must set the
102            UUID for the layout. Can set the creation date, modification
103            date, and expando bridge attributes for the layout. For layouts
104            that belong to a layout set prototype, an attribute named
105            <code>layoutUpdateable</code> can be used to specify whether site
106            administrators can modify this page within their site.
107            * @return the layout
108            */
109            public static com.liferay.portal.kernel.model.LayoutSoap addLayout(
110                    long groupId, boolean privateLayout, long parentLayoutId,
111                    java.lang.String[] localeNamesMapLanguageIds,
112                    java.lang.String[] localeNamesMapValues,
113                    java.lang.String[] localeTitlesMapLanguageIds,
114                    java.lang.String[] localeTitlesMapValues,
115                    java.lang.String[] descriptionMapLanguageIds,
116                    java.lang.String[] descriptionMapValues,
117                    java.lang.String[] keywordsMapLanguageIds,
118                    java.lang.String[] keywordsMapValues,
119                    java.lang.String[] robotsMapLanguageIds,
120                    java.lang.String[] robotsMapValues, java.lang.String type,
121                    java.lang.String typeSettings, boolean hidden,
122                    java.lang.String[] friendlyURLMapLanguageIds,
123                    java.lang.String[] friendlyURLMapValues,
124                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
125                    throws RemoteException {
126                    try {
127                            Map<Locale, String> localeNamesMap = LocalizationUtil.getLocalizationMap(localeNamesMapLanguageIds,
128                                            localeNamesMapValues);
129                            Map<Locale, String> localeTitlesMap = LocalizationUtil.getLocalizationMap(localeTitlesMapLanguageIds,
130                                            localeTitlesMapValues);
131                            Map<Locale, String> descriptionMap = LocalizationUtil.getLocalizationMap(descriptionMapLanguageIds,
132                                            descriptionMapValues);
133                            Map<Locale, String> keywordsMap = LocalizationUtil.getLocalizationMap(keywordsMapLanguageIds,
134                                            keywordsMapValues);
135                            Map<Locale, String> robotsMap = LocalizationUtil.getLocalizationMap(robotsMapLanguageIds,
136                                            robotsMapValues);
137                            Map<Locale, String> friendlyURLMap = LocalizationUtil.getLocalizationMap(friendlyURLMapLanguageIds,
138                                            friendlyURLMapValues);
139    
140                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.addLayout(groupId,
141                                            privateLayout, parentLayoutId, localeNamesMap,
142                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
143                                            type, typeSettings, hidden, friendlyURLMap, serviceContext);
144    
145                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
146                    }
147                    catch (Exception e) {
148                            _log.error(e, e);
149    
150                            throw new RemoteException(e.getMessage());
151                    }
152            }
153    
154            /**
155            * Adds a layout with single entry maps for name, title, and description to
156            * the default locale.
157            *
158            * <p>
159            * This method handles the creation of the layout including its resources,
160            * metadata, and internal data structures. It is not necessary to make
161            * subsequent calls to any methods to setup default groups, resources, ...
162            * etc.
163            * </p>
164            *
165            * @param groupId the primary key of the group
166            * @param privateLayout whether the layout is private to the group
167            * @param parentLayoutId the primary key of the parent layout (optionally
168            {@link LayoutConstants#DEFAULT_PARENT_LAYOUT_ID})
169            * @param name the layout's locales and localized names
170            * @param title the layout's locales and localized titles
171            * @param description the layout's locales and localized descriptions
172            * @param type the layout's type (optionally {@link
173            LayoutConstants#TYPE_PORTLET}). The possible types can be found
174            in {@link LayoutConstants}.
175            * @param hidden whether the layout is hidden
176            * @param friendlyURL the layout's locales and localized friendly URLs. To
177            see how the URL is normalized when accessed, see {@link
178            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
179            String)}.
180            * @param serviceContext the service context to be applied. Must set the
181            UUID for the layout. Can specify the creation date, modification
182            date, and expando bridge attributes for the layout. For layouts
183            that belong to a layout set prototype, an attribute named
184            <code>layoutUpdateable</code> can be used to specify whether site
185            administrators can modify this page within their site.
186            * @return the layout
187            */
188            public static com.liferay.portal.kernel.model.LayoutSoap addLayout(
189                    long groupId, boolean privateLayout, long parentLayoutId,
190                    java.lang.String name, java.lang.String title,
191                    java.lang.String description, java.lang.String type, boolean hidden,
192                    java.lang.String friendlyURL,
193                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
194                    throws RemoteException {
195                    try {
196                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.addLayout(groupId,
197                                            privateLayout, parentLayoutId, name, title, description,
198                                            type, hidden, friendlyURL, serviceContext);
199    
200                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
201                    }
202                    catch (Exception e) {
203                            _log.error(e, e);
204    
205                            throw new RemoteException(e.getMessage());
206                    }
207            }
208    
209            /**
210            * Deletes the layout with the primary key, also deleting the layout's child
211            * layouts, and associated resources.
212            *
213            * @param groupId the primary key of the group
214            * @param privateLayout whether the layout is private to the group
215            * @param layoutId the primary key of the layout
216            * @param serviceContext the service context to be applied
217            */
218            public static void deleteLayout(long groupId, boolean privateLayout,
219                    long layoutId,
220                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
221                    throws RemoteException {
222                    try {
223                            LayoutServiceUtil.deleteLayout(groupId, privateLayout, layoutId,
224                                    serviceContext);
225                    }
226                    catch (Exception e) {
227                            _log.error(e, e);
228    
229                            throw new RemoteException(e.getMessage());
230                    }
231            }
232    
233            /**
234            * Deletes the layout with the plid, also deleting the layout's child
235            * layouts, and associated resources.
236            *
237            * @param plid the primary key of the layout
238            * @param serviceContext the service context to be applied
239            */
240            public static void deleteLayout(long plid,
241                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
242                    throws RemoteException {
243                    try {
244                            LayoutServiceUtil.deleteLayout(plid, serviceContext);
245                    }
246                    catch (Exception e) {
247                            _log.error(e, e);
248    
249                            throw new RemoteException(e.getMessage());
250                    }
251            }
252    
253            public static void deleteTempFileEntry(long groupId,
254                    java.lang.String folderName, java.lang.String fileName)
255                    throws RemoteException {
256                    try {
257                            LayoutServiceUtil.deleteTempFileEntry(groupId, folderName, fileName);
258                    }
259                    catch (Exception e) {
260                            _log.error(e, e);
261    
262                            throw new RemoteException(e.getMessage());
263                    }
264            }
265    
266            /**
267            * @deprecated As of 7.0.0, replaced by {@link
268            com.liferay.exportimport.kernel.service.ExportImportService#exportLayoutsAsFileInBackground(
269            ExportImportConfiguration)}
270            */
271            @Deprecated
272            public static long exportLayoutsAsFileInBackground(
273                    com.liferay.exportimport.kernel.model.ExportImportConfigurationSoap exportImportConfiguration)
274                    throws RemoteException {
275                    try {
276                            long returnValue = LayoutServiceUtil.exportLayoutsAsFileInBackground(com.liferay.portlet.exportimport.model.impl.ExportImportConfigurationModelImpl.toModel(
277                                                    exportImportConfiguration));
278    
279                            return returnValue;
280                    }
281                    catch (Exception e) {
282                            _log.error(e, e);
283    
284                            throw new RemoteException(e.getMessage());
285                    }
286            }
287    
288            /**
289            * @deprecated As of 7.0.0, replaced by {@link
290            com.liferay.exportimport.kernel.service.ExportImportService#exportLayoutsAsFileInBackground(
291            long)}
292            */
293            @Deprecated
294            public static long exportLayoutsAsFileInBackground(
295                    long exportImportConfigurationId) throws RemoteException {
296                    try {
297                            long returnValue = LayoutServiceUtil.exportLayoutsAsFileInBackground(exportImportConfigurationId);
298    
299                            return returnValue;
300                    }
301                    catch (Exception e) {
302                            _log.error(e, e);
303    
304                            throw new RemoteException(e.getMessage());
305                    }
306            }
307    
308            /**
309            * Returns all the ancestor layouts of the layout.
310            *
311            * @param plid the primary key of the layout
312            * @return the ancestor layouts of the layout
313            */
314            public static com.liferay.portal.kernel.model.LayoutSoap[] getAncestorLayouts(
315                    long plid) throws RemoteException {
316                    try {
317                            java.util.List<com.liferay.portal.kernel.model.Layout> returnValue = LayoutServiceUtil.getAncestorLayouts(plid);
318    
319                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModels(returnValue);
320                    }
321                    catch (Exception e) {
322                            _log.error(e, e);
323    
324                            throw new RemoteException(e.getMessage());
325                    }
326            }
327    
328            /**
329            * Returns the primary key of the default layout for the group.
330            *
331            * @param groupId the primary key of the group
332            * @param scopeGroupId the primary key of the scope group. See {@link
333            ServiceContext#getScopeGroupId()}.
334            * @param privateLayout whether the layout is private to the group
335            * @param portletId the primary key of the portlet
336            * @return Returns the primary key of the default layout group; {@link
337            LayoutConstants#DEFAULT_PLID} otherwise
338            */
339            public static long getDefaultPlid(long groupId, long scopeGroupId,
340                    boolean privateLayout, java.lang.String portletId)
341                    throws RemoteException {
342                    try {
343                            long returnValue = LayoutServiceUtil.getDefaultPlid(groupId,
344                                            scopeGroupId, privateLayout, portletId);
345    
346                            return returnValue;
347                    }
348                    catch (Exception e) {
349                            _log.error(e, e);
350    
351                            throw new RemoteException(e.getMessage());
352                    }
353            }
354    
355            public static long getDefaultPlid(long groupId, long scopeGroupId,
356                    java.lang.String portletId) throws RemoteException {
357                    try {
358                            long returnValue = LayoutServiceUtil.getDefaultPlid(groupId,
359                                            scopeGroupId, portletId);
360    
361                            return returnValue;
362                    }
363                    catch (Exception e) {
364                            _log.error(e, e);
365    
366                            throw new RemoteException(e.getMessage());
367                    }
368            }
369    
370            /**
371            * Returns the layout matching the UUID, group, and privacy.
372            *
373            * @param uuid the layout's UUID
374            * @param groupId the primary key of the group
375            * @param privateLayout whether the layout is private to the group
376            * @return the matching layout
377            */
378            public static com.liferay.portal.kernel.model.LayoutSoap getLayoutByUuidAndGroupId(
379                    java.lang.String uuid, long groupId, boolean privateLayout)
380                    throws RemoteException {
381                    try {
382                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.getLayoutByUuidAndGroupId(uuid,
383                                            groupId, privateLayout);
384    
385                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
386                    }
387                    catch (Exception e) {
388                            _log.error(e, e);
389    
390                            throw new RemoteException(e.getMessage());
391                    }
392            }
393    
394            /**
395            * Returns the name of the layout.
396            *
397            * @param groupId the primary key of the group
398            * @param privateLayout whether the layout is private to the group
399            * @param layoutId the primary key of the layout
400            * @param languageId the primary key of the language. For more information
401            See {@link Locale}.
402            * @return the layout's name
403            */
404            public static java.lang.String getLayoutName(long groupId,
405                    boolean privateLayout, long layoutId, java.lang.String languageId)
406                    throws RemoteException {
407                    try {
408                            java.lang.String returnValue = LayoutServiceUtil.getLayoutName(groupId,
409                                            privateLayout, layoutId, languageId);
410    
411                            return returnValue;
412                    }
413                    catch (Exception e) {
414                            _log.error(e, e);
415    
416                            throw new RemoteException(e.getMessage());
417                    }
418            }
419    
420            /**
421            * Returns the layout references for all the layouts that belong to the
422            * company and belong to the portlet that matches the preferences.
423            *
424            * @param companyId the primary key of the company
425            * @param portletId the primary key of the portlet
426            * @param preferencesKey the portlet's preference key
427            * @param preferencesValue the portlet's preference value
428            * @return the layout references of the matching layouts
429            */
430            public static com.liferay.portal.kernel.model.LayoutReference[] getLayoutReferences(
431                    long companyId, java.lang.String portletId,
432                    java.lang.String preferencesKey, java.lang.String preferencesValue)
433                    throws RemoteException {
434                    try {
435                            com.liferay.portal.kernel.model.LayoutReference[] returnValue = LayoutServiceUtil.getLayoutReferences(companyId,
436                                            portletId, preferencesKey, preferencesValue);
437    
438                            return returnValue;
439                    }
440                    catch (Exception e) {
441                            _log.error(e, e);
442    
443                            throw new RemoteException(e.getMessage());
444                    }
445            }
446    
447            public static com.liferay.portal.kernel.model.LayoutSoap[] getLayouts(
448                    long groupId, boolean privateLayout) throws RemoteException {
449                    try {
450                            java.util.List<com.liferay.portal.kernel.model.Layout> returnValue = LayoutServiceUtil.getLayouts(groupId,
451                                            privateLayout);
452    
453                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModels(returnValue);
454                    }
455                    catch (Exception e) {
456                            _log.error(e, e);
457    
458                            throw new RemoteException(e.getMessage());
459                    }
460            }
461    
462            public static com.liferay.portal.kernel.model.LayoutSoap[] getLayouts(
463                    long groupId, boolean privateLayout, long parentLayoutId)
464                    throws RemoteException {
465                    try {
466                            java.util.List<com.liferay.portal.kernel.model.Layout> returnValue = LayoutServiceUtil.getLayouts(groupId,
467                                            privateLayout, parentLayoutId);
468    
469                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModels(returnValue);
470                    }
471                    catch (Exception e) {
472                            _log.error(e, e);
473    
474                            throw new RemoteException(e.getMessage());
475                    }
476            }
477    
478            public static com.liferay.portal.kernel.model.LayoutSoap[] getLayouts(
479                    long groupId, boolean privateLayout, long parentLayoutId,
480                    boolean incomplete, int start, int end) throws RemoteException {
481                    try {
482                            java.util.List<com.liferay.portal.kernel.model.Layout> returnValue = LayoutServiceUtil.getLayouts(groupId,
483                                            privateLayout, parentLayoutId, incomplete, start, end);
484    
485                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModels(returnValue);
486                    }
487                    catch (Exception e) {
488                            _log.error(e, e);
489    
490                            throw new RemoteException(e.getMessage());
491                    }
492            }
493    
494            public static int getLayoutsCount(long groupId, boolean privateLayout,
495                    long parentLayoutId) throws RemoteException {
496                    try {
497                            int returnValue = LayoutServiceUtil.getLayoutsCount(groupId,
498                                            privateLayout, parentLayoutId);
499    
500                            return returnValue;
501                    }
502                    catch (Exception e) {
503                            _log.error(e, e);
504    
505                            throw new RemoteException(e.getMessage());
506                    }
507            }
508    
509            public static java.lang.String[] getTempFileNames(long groupId,
510                    java.lang.String folderName) throws RemoteException {
511                    try {
512                            java.lang.String[] returnValue = LayoutServiceUtil.getTempFileNames(groupId,
513                                            folderName);
514    
515                            return returnValue;
516                    }
517                    catch (Exception e) {
518                            _log.error(e, e);
519    
520                            throw new RemoteException(e.getMessage());
521                    }
522            }
523    
524            /**
525            * Sets the layouts for the group, replacing and prioritizing all layouts of
526            * the parent layout.
527            *
528            * @param groupId the primary key of the group
529            * @param privateLayout whether the layout is private to the group
530            * @param parentLayoutId the primary key of the parent layout
531            * @param layoutIds the primary keys of the layouts
532            * @param serviceContext the service context to be applied
533            */
534            public static void setLayouts(long groupId, boolean privateLayout,
535                    long parentLayoutId, long[] layoutIds,
536                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
537                    throws RemoteException {
538                    try {
539                            LayoutServiceUtil.setLayouts(groupId, privateLayout,
540                                    parentLayoutId, layoutIds, serviceContext);
541                    }
542                    catch (Exception e) {
543                            _log.error(e, e);
544    
545                            throw new RemoteException(e.getMessage());
546                    }
547            }
548    
549            /**
550            * Deletes the job from the scheduler's queue.
551            *
552            * @param groupId the primary key of the group
553            * @param jobName the job name
554            * @param groupName the group name (optionally {@link
555            DestinationNames#LAYOUTS_LOCAL_PUBLISHER}). See {@link
556            DestinationNames}.
557            */
558            public static void unschedulePublishToLive(long groupId,
559                    java.lang.String jobName, java.lang.String groupName)
560                    throws RemoteException {
561                    try {
562                            LayoutServiceUtil.unschedulePublishToLive(groupId, jobName,
563                                    groupName);
564                    }
565                    catch (Exception e) {
566                            _log.error(e, e);
567    
568                            throw new RemoteException(e.getMessage());
569                    }
570            }
571    
572            /**
573            * Deletes the job from the scheduler's persistent queue.
574            *
575            * @param groupId the primary key of the group
576            * @param jobName the job name
577            * @param groupName the group name (optionally {@link
578            DestinationNames#LAYOUTS_LOCAL_PUBLISHER}). See {@link
579            DestinationNames}.
580            */
581            public static void unschedulePublishToRemote(long groupId,
582                    java.lang.String jobName, java.lang.String groupName)
583                    throws RemoteException {
584                    try {
585                            LayoutServiceUtil.unschedulePublishToRemote(groupId, jobName,
586                                    groupName);
587                    }
588                    catch (Exception e) {
589                            _log.error(e, e);
590    
591                            throw new RemoteException(e.getMessage());
592                    }
593            }
594    
595            public static com.liferay.portal.kernel.model.LayoutSoap updateIconImage(
596                    long plid, byte[] bytes) throws RemoteException {
597                    try {
598                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateIconImage(plid,
599                                            bytes);
600    
601                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
602                    }
603                    catch (Exception e) {
604                            _log.error(e, e);
605    
606                            throw new RemoteException(e.getMessage());
607                    }
608            }
609    
610            /**
611            * Updates the layout with additional parameters.
612            *
613            * @param groupId the primary key of the group
614            * @param privateLayout whether the layout is private to the group
615            * @param layoutId the primary key of the layout
616            * @param parentLayoutId the primary key of the layout's new parent layout
617            * @param localeNamesMap the layout's locales and localized names
618            * @param localeTitlesMap the layout's locales and localized titles
619            * @param descriptionMap the locales and localized descriptions to merge
620            (optionally <code>null</code>)
621            * @param keywordsMap the locales and localized keywords to merge
622            (optionally <code>null</code>)
623            * @param robotsMap the locales and localized robots to merge (optionally
624            <code>null</code>)
625            * @param type the layout's new type (optionally {@link
626            LayoutConstants#TYPE_PORTLET})
627            * @param hidden whether the layout is hidden
628            * @param friendlyURLMap the layout's locales and localized friendly URLs.
629            To see how the URL is normalized when accessed see {@link
630            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
631            String)}.
632            * @param iconImage whether the icon image will be updated
633            * @param iconBytes the byte array of the layout's new icon image
634            * @param serviceContext the service context to be applied. Can set the
635            modification date and expando bridge attributes for the layout.
636            * @return the updated layout
637            */
638            public static com.liferay.portal.kernel.model.LayoutSoap updateLayout(
639                    long groupId, boolean privateLayout, long layoutId,
640                    long parentLayoutId, java.lang.String[] localeNamesMapLanguageIds,
641                    java.lang.String[] localeNamesMapValues,
642                    java.lang.String[] localeTitlesMapLanguageIds,
643                    java.lang.String[] localeTitlesMapValues,
644                    java.lang.String[] descriptionMapLanguageIds,
645                    java.lang.String[] descriptionMapValues,
646                    java.lang.String[] keywordsMapLanguageIds,
647                    java.lang.String[] keywordsMapValues,
648                    java.lang.String[] robotsMapLanguageIds,
649                    java.lang.String[] robotsMapValues, java.lang.String type,
650                    boolean hidden, java.lang.String[] friendlyURLMapLanguageIds,
651                    java.lang.String[] friendlyURLMapValues, boolean iconImage,
652                    byte[] iconBytes,
653                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
654                    throws RemoteException {
655                    try {
656                            Map<Locale, String> localeNamesMap = LocalizationUtil.getLocalizationMap(localeNamesMapLanguageIds,
657                                            localeNamesMapValues);
658                            Map<Locale, String> localeTitlesMap = LocalizationUtil.getLocalizationMap(localeTitlesMapLanguageIds,
659                                            localeTitlesMapValues);
660                            Map<Locale, String> descriptionMap = LocalizationUtil.getLocalizationMap(descriptionMapLanguageIds,
661                                            descriptionMapValues);
662                            Map<Locale, String> keywordsMap = LocalizationUtil.getLocalizationMap(keywordsMapLanguageIds,
663                                            keywordsMapValues);
664                            Map<Locale, String> robotsMap = LocalizationUtil.getLocalizationMap(robotsMapLanguageIds,
665                                            robotsMapValues);
666                            Map<Locale, String> friendlyURLMap = LocalizationUtil.getLocalizationMap(friendlyURLMapLanguageIds,
667                                            friendlyURLMapValues);
668    
669                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateLayout(groupId,
670                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
671                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
672                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
673                                            serviceContext);
674    
675                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
676                    }
677                    catch (Exception e) {
678                            _log.error(e, e);
679    
680                            throw new RemoteException(e.getMessage());
681                    }
682            }
683    
684            /**
685            * Updates the layout replacing its type settings.
686            *
687            * @param groupId the primary key of the group
688            * @param privateLayout whether the layout is private to the group
689            * @param layoutId the primary key of the layout
690            * @param typeSettings the settings to load the unicode properties object.
691            See {@link com.liferay.portal.kernel.util.UnicodeProperties
692            #fastLoad(String)}.
693            * @return the updated layout
694            */
695            public static com.liferay.portal.kernel.model.LayoutSoap updateLayout(
696                    long groupId, boolean privateLayout, long layoutId,
697                    java.lang.String typeSettings) throws RemoteException {
698                    try {
699                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateLayout(groupId,
700                                            privateLayout, layoutId, typeSettings);
701    
702                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
703                    }
704                    catch (Exception e) {
705                            _log.error(e, e);
706    
707                            throw new RemoteException(e.getMessage());
708                    }
709            }
710    
711            /**
712            * Updates the look and feel of the layout.
713            *
714            * @param groupId the primary key of the group
715            * @param privateLayout whether the layout is private to the group
716            * @param layoutId the primary key of the layout
717            * @param themeId the primary key of the layout's new theme
718            * @param colorSchemeId the primary key of the layout's new color scheme
719            * @param css the layout's new CSS
720            * @return the updated layout
721            */
722            public static com.liferay.portal.kernel.model.LayoutSoap updateLookAndFeel(
723                    long groupId, boolean privateLayout, long layoutId,
724                    java.lang.String themeId, java.lang.String colorSchemeId,
725                    java.lang.String css) throws RemoteException {
726                    try {
727                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateLookAndFeel(groupId,
728                                            privateLayout, layoutId, themeId, colorSchemeId, css);
729    
730                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
731                    }
732                    catch (Exception e) {
733                            _log.error(e, e);
734    
735                            throw new RemoteException(e.getMessage());
736                    }
737            }
738    
739            /**
740            * Updates the name of the layout matching the group, layout ID, and
741            * privacy.
742            *
743            * @param groupId the primary key of the group
744            * @param privateLayout whether the layout is private to the group
745            * @param layoutId the primary key of the layout
746            * @param name the layout's new name
747            * @param languageId the primary key of the language. For more information
748            see {@link Locale}.
749            * @return the updated layout
750            */
751            public static com.liferay.portal.kernel.model.LayoutSoap updateName(
752                    long groupId, boolean privateLayout, long layoutId,
753                    java.lang.String name, java.lang.String languageId)
754                    throws RemoteException {
755                    try {
756                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateName(groupId,
757                                            privateLayout, layoutId, name, languageId);
758    
759                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
760                    }
761                    catch (Exception e) {
762                            _log.error(e, e);
763    
764                            throw new RemoteException(e.getMessage());
765                    }
766            }
767    
768            /**
769            * Updates the name of the layout matching the primary key.
770            *
771            * @param plid the primary key of the layout
772            * @param name the name to be assigned
773            * @param languageId the primary key of the language. For more information
774            see {@link Locale}.
775            * @return the updated layout
776            */
777            public static com.liferay.portal.kernel.model.LayoutSoap updateName(
778                    long plid, java.lang.String name, java.lang.String languageId)
779                    throws RemoteException {
780                    try {
781                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateName(plid,
782                                            name, languageId);
783    
784                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
785                    }
786                    catch (Exception e) {
787                            _log.error(e, e);
788    
789                            throw new RemoteException(e.getMessage());
790                    }
791            }
792    
793            /**
794            * Updates the parent layout ID of the layout matching the group, layout ID,
795            * and privacy.
796            *
797            * @param groupId the primary key of the group
798            * @param privateLayout whether the layout is private to the group
799            * @param layoutId the primary key of the layout
800            * @param parentLayoutId the primary key to be assigned to the parent
801            layout
802            * @return the matching layout
803            */
804            public static com.liferay.portal.kernel.model.LayoutSoap updateParentLayoutId(
805                    long groupId, boolean privateLayout, long layoutId, long parentLayoutId)
806                    throws RemoteException {
807                    try {
808                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateParentLayoutId(groupId,
809                                            privateLayout, layoutId, parentLayoutId);
810    
811                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
812                    }
813                    catch (Exception e) {
814                            _log.error(e, e);
815    
816                            throw new RemoteException(e.getMessage());
817                    }
818            }
819    
820            /**
821            * Updates the parent layout ID of the layout matching the primary key. If a
822            * layout matching the parent primary key is found, the layout ID of that
823            * layout is assigned, otherwise {@link
824            * LayoutConstants#DEFAULT_PARENT_LAYOUT_ID} is assigned.
825            *
826            * @param plid the primary key of the layout
827            * @param parentPlid the primary key of the parent layout
828            * @return the layout matching the primary key
829            */
830            public static com.liferay.portal.kernel.model.LayoutSoap updateParentLayoutId(
831                    long plid, long parentPlid) throws RemoteException {
832                    try {
833                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateParentLayoutId(plid,
834                                            parentPlid);
835    
836                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
837                    }
838                    catch (Exception e) {
839                            _log.error(e, e);
840    
841                            throw new RemoteException(e.getMessage());
842                    }
843            }
844    
845            /**
846            * Updates the parent layout ID and priority of the layout.
847            *
848            * @param plid the primary key of the layout
849            * @param parentPlid the primary key of the parent layout
850            * @param priority the layout's new priority
851            * @return the layout matching the primary key
852            */
853            public static com.liferay.portal.kernel.model.LayoutSoap updateParentLayoutIdAndPriority(
854                    long plid, long parentPlid, int priority) throws RemoteException {
855                    try {
856                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updateParentLayoutIdAndPriority(plid,
857                                            parentPlid, priority);
858    
859                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
860                    }
861                    catch (Exception e) {
862                            _log.error(e, e);
863    
864                            throw new RemoteException(e.getMessage());
865                    }
866            }
867    
868            /**
869            * Updates the priority of the layout matching the group, layout ID, and
870            * privacy.
871            *
872            * @param groupId the primary key of the group
873            * @param privateLayout whether the layout is private to the group
874            * @param layoutId the primary key of the layout
875            * @param priority the layout's new priority
876            * @return the updated layout
877            */
878            public static com.liferay.portal.kernel.model.LayoutSoap updatePriority(
879                    long groupId, boolean privateLayout, long layoutId, int priority)
880                    throws RemoteException {
881                    try {
882                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updatePriority(groupId,
883                                            privateLayout, layoutId, priority);
884    
885                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
886                    }
887                    catch (Exception e) {
888                            _log.error(e, e);
889    
890                            throw new RemoteException(e.getMessage());
891                    }
892            }
893    
894            /**
895            * Updates the priority of the layout matching the group, layout ID, and
896            * privacy, setting the layout's priority based on the priorities of the
897            * next and previous layouts.
898            *
899            * @param groupId the primary key of the group
900            * @param privateLayout whether the layout is private to the group
901            * @param layoutId the primary key of the layout
902            * @param nextLayoutId the primary key of the next layout
903            * @param previousLayoutId the primary key of the previous layout
904            * @return the updated layout
905            */
906            public static com.liferay.portal.kernel.model.LayoutSoap updatePriority(
907                    long groupId, boolean privateLayout, long layoutId, long nextLayoutId,
908                    long previousLayoutId) throws RemoteException {
909                    try {
910                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updatePriority(groupId,
911                                            privateLayout, layoutId, nextLayoutId, previousLayoutId);
912    
913                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
914                    }
915                    catch (Exception e) {
916                            _log.error(e, e);
917    
918                            throw new RemoteException(e.getMessage());
919                    }
920            }
921    
922            /**
923            * Updates the priority of the layout matching the primary key.
924            *
925            * @param plid the primary key of the layout
926            * @param priority the layout's new priority
927            * @return the updated layout
928            */
929            public static com.liferay.portal.kernel.model.LayoutSoap updatePriority(
930                    long plid, int priority) throws RemoteException {
931                    try {
932                            com.liferay.portal.kernel.model.Layout returnValue = LayoutServiceUtil.updatePriority(plid,
933                                            priority);
934    
935                            return com.liferay.portal.kernel.model.LayoutSoap.toSoapModel(returnValue);
936                    }
937                    catch (Exception e) {
938                            _log.error(e, e);
939    
940                            throw new RemoteException(e.getMessage());
941                    }
942            }
943    
944            private static Log _log = LogFactoryUtil.getLog(LayoutServiceSoap.class);
945    }