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.LocalizationUtil;
022    import com.liferay.portal.service.LayoutServiceUtil;
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.model.LayoutSoap}.
040     * If the method in the service utility returns a
041     * {@link com.liferay.portal.model.Layout}, that is translated to a
042     * {@link com.liferay.portal.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.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.model.LayoutSoap addLayout(long groupId,
110                    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.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.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.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.model.LayoutSoap addLayout(long groupId,
189                    boolean privateLayout, long parentLayoutId, java.lang.String name,
190                    java.lang.String title, java.lang.String description,
191                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
192                    com.liferay.portal.service.ServiceContext serviceContext)
193                    throws RemoteException {
194                    try {
195                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.addLayout(groupId,
196                                            privateLayout, parentLayoutId, name, title, description,
197                                            type, hidden, friendlyURL, serviceContext);
198    
199                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
200                    }
201                    catch (Exception e) {
202                            _log.error(e, e);
203    
204                            throw new RemoteException(e.getMessage());
205                    }
206            }
207    
208            /**
209            * Deletes the layout with the primary key, also deleting the layout's child
210            * layouts, and associated resources.
211            *
212            * @param groupId the primary key of the group
213            * @param privateLayout whether the layout is private to the group
214            * @param layoutId the primary key of the layout
215            * @param serviceContext the service context to be applied
216            */
217            public static void deleteLayout(long groupId, boolean privateLayout,
218                    long layoutId, com.liferay.portal.service.ServiceContext serviceContext)
219                    throws RemoteException {
220                    try {
221                            LayoutServiceUtil.deleteLayout(groupId, privateLayout, layoutId,
222                                    serviceContext);
223                    }
224                    catch (Exception e) {
225                            _log.error(e, e);
226    
227                            throw new RemoteException(e.getMessage());
228                    }
229            }
230    
231            /**
232            * Deletes the layout with the plid, also deleting the layout's child
233            * layouts, and associated resources.
234            *
235            * @param plid the primary key of the layout
236            * @param serviceContext the service context to be applied
237            */
238            public static void deleteLayout(long plid,
239                    com.liferay.portal.service.ServiceContext serviceContext)
240                    throws RemoteException {
241                    try {
242                            LayoutServiceUtil.deleteLayout(plid, serviceContext);
243                    }
244                    catch (Exception e) {
245                            _log.error(e, e);
246    
247                            throw new RemoteException(e.getMessage());
248                    }
249            }
250    
251            public static void deleteTempFileEntry(long groupId,
252                    java.lang.String folderName, java.lang.String fileName)
253                    throws RemoteException {
254                    try {
255                            LayoutServiceUtil.deleteTempFileEntry(groupId, folderName, fileName);
256                    }
257                    catch (Exception e) {
258                            _log.error(e, e);
259    
260                            throw new RemoteException(e.getMessage());
261                    }
262            }
263    
264            /**
265            * @deprecated As of 7.0.0, replaced by {@link
266            com.liferay.portlet.exportimport.service.ExportImportService#exportLayoutsAsFileInBackground(
267            ExportImportConfiguration)}
268            */
269            @Deprecated
270            public static long exportLayoutsAsFileInBackground(
271                    com.liferay.portlet.exportimport.model.ExportImportConfigurationSoap exportImportConfiguration)
272                    throws RemoteException {
273                    try {
274                            long returnValue = LayoutServiceUtil.exportLayoutsAsFileInBackground(com.liferay.portlet.exportimport.model.impl.ExportImportConfigurationModelImpl.toModel(
275                                                    exportImportConfiguration));
276    
277                            return returnValue;
278                    }
279                    catch (Exception e) {
280                            _log.error(e, e);
281    
282                            throw new RemoteException(e.getMessage());
283                    }
284            }
285    
286            /**
287            * @deprecated As of 7.0.0, replaced by {@link
288            com.liferay.portlet.exportimport.service.ExportImportService#exportLayoutsAsFileInBackground(
289            long)}
290            */
291            @Deprecated
292            public static long exportLayoutsAsFileInBackground(
293                    long exportImportConfigurationId) throws RemoteException {
294                    try {
295                            long returnValue = LayoutServiceUtil.exportLayoutsAsFileInBackground(exportImportConfigurationId);
296    
297                            return returnValue;
298                    }
299                    catch (Exception e) {
300                            _log.error(e, e);
301    
302                            throw new RemoteException(e.getMessage());
303                    }
304            }
305    
306            /**
307            * Returns all the ancestor layouts of the layout.
308            *
309            * @param plid the primary key of the layout
310            * @return the ancestor layouts of the layout
311            */
312            public static com.liferay.portal.model.LayoutSoap[] getAncestorLayouts(
313                    long plid) throws RemoteException {
314                    try {
315                            java.util.List<com.liferay.portal.model.Layout> returnValue = LayoutServiceUtil.getAncestorLayouts(plid);
316    
317                            return com.liferay.portal.model.LayoutSoap.toSoapModels(returnValue);
318                    }
319                    catch (Exception e) {
320                            _log.error(e, e);
321    
322                            throw new RemoteException(e.getMessage());
323                    }
324            }
325    
326            /**
327            * Returns the primary key of the default layout for the group.
328            *
329            * @param groupId the primary key of the group
330            * @param scopeGroupId the primary key of the scope group. See {@link
331            ServiceContext#getScopeGroupId()}.
332            * @param privateLayout whether the layout is private to the group
333            * @param portletId the primary key of the portlet
334            * @return Returns the primary key of the default layout group; {@link
335            LayoutConstants#DEFAULT_PLID} otherwise
336            */
337            public static long getDefaultPlid(long groupId, long scopeGroupId,
338                    boolean privateLayout, java.lang.String portletId)
339                    throws RemoteException {
340                    try {
341                            long returnValue = LayoutServiceUtil.getDefaultPlid(groupId,
342                                            scopeGroupId, privateLayout, portletId);
343    
344                            return returnValue;
345                    }
346                    catch (Exception e) {
347                            _log.error(e, e);
348    
349                            throw new RemoteException(e.getMessage());
350                    }
351            }
352    
353            public static long getDefaultPlid(long groupId, long scopeGroupId,
354                    java.lang.String portletId) throws RemoteException {
355                    try {
356                            long returnValue = LayoutServiceUtil.getDefaultPlid(groupId,
357                                            scopeGroupId, portletId);
358    
359                            return returnValue;
360                    }
361                    catch (Exception e) {
362                            _log.error(e, e);
363    
364                            throw new RemoteException(e.getMessage());
365                    }
366            }
367    
368            /**
369            * Returns the layout matching the UUID, group, and privacy.
370            *
371            * @param uuid the layout's UUID
372            * @param groupId the primary key of the group
373            * @param privateLayout whether the layout is private to the group
374            * @return the matching layout
375            */
376            public static com.liferay.portal.model.LayoutSoap getLayoutByUuidAndGroupId(
377                    java.lang.String uuid, long groupId, boolean privateLayout)
378                    throws RemoteException {
379                    try {
380                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.getLayoutByUuidAndGroupId(uuid,
381                                            groupId, privateLayout);
382    
383                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
384                    }
385                    catch (Exception e) {
386                            _log.error(e, e);
387    
388                            throw new RemoteException(e.getMessage());
389                    }
390            }
391    
392            /**
393            * Returns the name of the layout.
394            *
395            * @param groupId the primary key of the group
396            * @param privateLayout whether the layout is private to the group
397            * @param layoutId the primary key of the layout
398            * @param languageId the primary key of the language. For more information
399            See {@link Locale}.
400            * @return the layout's name
401            */
402            public static java.lang.String getLayoutName(long groupId,
403                    boolean privateLayout, long layoutId, java.lang.String languageId)
404                    throws RemoteException {
405                    try {
406                            java.lang.String returnValue = LayoutServiceUtil.getLayoutName(groupId,
407                                            privateLayout, layoutId, languageId);
408    
409                            return returnValue;
410                    }
411                    catch (Exception e) {
412                            _log.error(e, e);
413    
414                            throw new RemoteException(e.getMessage());
415                    }
416            }
417    
418            /**
419            * Returns the layout references for all the layouts that belong to the
420            * company and belong to the portlet that matches the preferences.
421            *
422            * @param companyId the primary key of the company
423            * @param portletId the primary key of the portlet
424            * @param preferencesKey the portlet's preference key
425            * @param preferencesValue the portlet's preference value
426            * @return the layout references of the matching layouts
427            */
428            public static com.liferay.portal.model.LayoutReference[] getLayoutReferences(
429                    long companyId, java.lang.String portletId,
430                    java.lang.String preferencesKey, java.lang.String preferencesValue)
431                    throws RemoteException {
432                    try {
433                            com.liferay.portal.model.LayoutReference[] returnValue = LayoutServiceUtil.getLayoutReferences(companyId,
434                                            portletId, preferencesKey, preferencesValue);
435    
436                            return returnValue;
437                    }
438                    catch (Exception e) {
439                            _log.error(e, e);
440    
441                            throw new RemoteException(e.getMessage());
442                    }
443            }
444    
445            public static com.liferay.portal.model.LayoutSoap[] getLayouts(
446                    long groupId, boolean privateLayout) throws RemoteException {
447                    try {
448                            java.util.List<com.liferay.portal.model.Layout> returnValue = LayoutServiceUtil.getLayouts(groupId,
449                                            privateLayout);
450    
451                            return com.liferay.portal.model.LayoutSoap.toSoapModels(returnValue);
452                    }
453                    catch (Exception e) {
454                            _log.error(e, e);
455    
456                            throw new RemoteException(e.getMessage());
457                    }
458            }
459    
460            public static com.liferay.portal.model.LayoutSoap[] getLayouts(
461                    long groupId, boolean privateLayout, long parentLayoutId)
462                    throws RemoteException {
463                    try {
464                            java.util.List<com.liferay.portal.model.Layout> returnValue = LayoutServiceUtil.getLayouts(groupId,
465                                            privateLayout, parentLayoutId);
466    
467                            return com.liferay.portal.model.LayoutSoap.toSoapModels(returnValue);
468                    }
469                    catch (Exception e) {
470                            _log.error(e, e);
471    
472                            throw new RemoteException(e.getMessage());
473                    }
474            }
475    
476            public static com.liferay.portal.model.LayoutSoap[] getLayouts(
477                    long groupId, boolean privateLayout, long parentLayoutId,
478                    boolean incomplete, int start, int end) throws RemoteException {
479                    try {
480                            java.util.List<com.liferay.portal.model.Layout> returnValue = LayoutServiceUtil.getLayouts(groupId,
481                                            privateLayout, parentLayoutId, incomplete, start, end);
482    
483                            return com.liferay.portal.model.LayoutSoap.toSoapModels(returnValue);
484                    }
485                    catch (Exception e) {
486                            _log.error(e, e);
487    
488                            throw new RemoteException(e.getMessage());
489                    }
490            }
491    
492            public static int getLayoutsCount(long groupId, boolean privateLayout,
493                    long parentLayoutId) throws RemoteException {
494                    try {
495                            int returnValue = LayoutServiceUtil.getLayoutsCount(groupId,
496                                            privateLayout, parentLayoutId);
497    
498                            return returnValue;
499                    }
500                    catch (Exception e) {
501                            _log.error(e, e);
502    
503                            throw new RemoteException(e.getMessage());
504                    }
505            }
506    
507            public static java.lang.String[] getTempFileNames(long groupId,
508                    java.lang.String folderName) throws RemoteException {
509                    try {
510                            java.lang.String[] returnValue = LayoutServiceUtil.getTempFileNames(groupId,
511                                            folderName);
512    
513                            return returnValue;
514                    }
515                    catch (Exception e) {
516                            _log.error(e, e);
517    
518                            throw new RemoteException(e.getMessage());
519                    }
520            }
521    
522            /**
523            * Sets the layouts for the group, replacing and prioritizing all layouts of
524            * the parent layout.
525            *
526            * @param groupId the primary key of the group
527            * @param privateLayout whether the layout is private to the group
528            * @param parentLayoutId the primary key of the parent layout
529            * @param layoutIds the primary keys of the layouts
530            * @param serviceContext the service context to be applied
531            */
532            public static void setLayouts(long groupId, boolean privateLayout,
533                    long parentLayoutId, long[] layoutIds,
534                    com.liferay.portal.service.ServiceContext serviceContext)
535                    throws RemoteException {
536                    try {
537                            LayoutServiceUtil.setLayouts(groupId, privateLayout,
538                                    parentLayoutId, layoutIds, serviceContext);
539                    }
540                    catch (Exception e) {
541                            _log.error(e, e);
542    
543                            throw new RemoteException(e.getMessage());
544                    }
545            }
546    
547            /**
548            * Deletes the job from the scheduler's queue.
549            *
550            * @param groupId the primary key of the group
551            * @param jobName the job name
552            * @param groupName the group name (optionally {@link
553            DestinationNames#LAYOUTS_LOCAL_PUBLISHER}). See {@link
554            DestinationNames}.
555            */
556            public static void unschedulePublishToLive(long groupId,
557                    java.lang.String jobName, java.lang.String groupName)
558                    throws RemoteException {
559                    try {
560                            LayoutServiceUtil.unschedulePublishToLive(groupId, jobName,
561                                    groupName);
562                    }
563                    catch (Exception e) {
564                            _log.error(e, e);
565    
566                            throw new RemoteException(e.getMessage());
567                    }
568            }
569    
570            /**
571            * Deletes the job from the scheduler's persistent queue.
572            *
573            * @param groupId the primary key of the group
574            * @param jobName the job name
575            * @param groupName the group name (optionally {@link
576            DestinationNames#LAYOUTS_LOCAL_PUBLISHER}). See {@link
577            DestinationNames}.
578            */
579            public static void unschedulePublishToRemote(long groupId,
580                    java.lang.String jobName, java.lang.String groupName)
581                    throws RemoteException {
582                    try {
583                            LayoutServiceUtil.unschedulePublishToRemote(groupId, jobName,
584                                    groupName);
585                    }
586                    catch (Exception e) {
587                            _log.error(e, e);
588    
589                            throw new RemoteException(e.getMessage());
590                    }
591            }
592    
593            public static com.liferay.portal.model.LayoutSoap updateIconImage(
594                    long plid, byte[] bytes) throws RemoteException {
595                    try {
596                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateIconImage(plid,
597                                            bytes);
598    
599                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
600                    }
601                    catch (Exception e) {
602                            _log.error(e, e);
603    
604                            throw new RemoteException(e.getMessage());
605                    }
606            }
607    
608            /**
609            * Updates the layout with additional parameters.
610            *
611            * @param groupId the primary key of the group
612            * @param privateLayout whether the layout is private to the group
613            * @param layoutId the primary key of the layout
614            * @param parentLayoutId the primary key of the layout's new parent layout
615            * @param localeNamesMap the layout's locales and localized names
616            * @param localeTitlesMap the layout's locales and localized titles
617            * @param descriptionMap the locales and localized descriptions to merge
618            (optionally <code>null</code>)
619            * @param keywordsMap the locales and localized keywords to merge
620            (optionally <code>null</code>)
621            * @param robotsMap the locales and localized robots to merge (optionally
622            <code>null</code>)
623            * @param type the layout's new type (optionally {@link
624            LayoutConstants#TYPE_PORTLET})
625            * @param hidden whether the layout is hidden
626            * @param friendlyURLMap the layout's locales and localized friendly URLs.
627            To see how the URL is normalized when accessed see {@link
628            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
629            String)}.
630            * @param iconImage whether the icon image will be updated
631            * @param iconBytes the byte array of the layout's new icon image
632            * @param serviceContext the service context to be applied. Can set the
633            modification date and expando bridge attributes for the layout.
634            * @return the updated layout
635            */
636            public static com.liferay.portal.model.LayoutSoap updateLayout(
637                    long groupId, boolean privateLayout, long layoutId,
638                    long parentLayoutId, java.lang.String[] localeNamesMapLanguageIds,
639                    java.lang.String[] localeNamesMapValues,
640                    java.lang.String[] localeTitlesMapLanguageIds,
641                    java.lang.String[] localeTitlesMapValues,
642                    java.lang.String[] descriptionMapLanguageIds,
643                    java.lang.String[] descriptionMapValues,
644                    java.lang.String[] keywordsMapLanguageIds,
645                    java.lang.String[] keywordsMapValues,
646                    java.lang.String[] robotsMapLanguageIds,
647                    java.lang.String[] robotsMapValues, java.lang.String type,
648                    boolean hidden, java.lang.String[] friendlyURLMapLanguageIds,
649                    java.lang.String[] friendlyURLMapValues, boolean iconImage,
650                    byte[] iconBytes,
651                    com.liferay.portal.service.ServiceContext serviceContext)
652                    throws RemoteException {
653                    try {
654                            Map<Locale, String> localeNamesMap = LocalizationUtil.getLocalizationMap(localeNamesMapLanguageIds,
655                                            localeNamesMapValues);
656                            Map<Locale, String> localeTitlesMap = LocalizationUtil.getLocalizationMap(localeTitlesMapLanguageIds,
657                                            localeTitlesMapValues);
658                            Map<Locale, String> descriptionMap = LocalizationUtil.getLocalizationMap(descriptionMapLanguageIds,
659                                            descriptionMapValues);
660                            Map<Locale, String> keywordsMap = LocalizationUtil.getLocalizationMap(keywordsMapLanguageIds,
661                                            keywordsMapValues);
662                            Map<Locale, String> robotsMap = LocalizationUtil.getLocalizationMap(robotsMapLanguageIds,
663                                            robotsMapValues);
664                            Map<Locale, String> friendlyURLMap = LocalizationUtil.getLocalizationMap(friendlyURLMapLanguageIds,
665                                            friendlyURLMapValues);
666    
667                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateLayout(groupId,
668                                            privateLayout, layoutId, parentLayoutId, localeNamesMap,
669                                            localeTitlesMap, descriptionMap, keywordsMap, robotsMap,
670                                            type, hidden, friendlyURLMap, iconImage, iconBytes,
671                                            serviceContext);
672    
673                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
674                    }
675                    catch (Exception e) {
676                            _log.error(e, e);
677    
678                            throw new RemoteException(e.getMessage());
679                    }
680            }
681    
682            /**
683            * Updates the layout replacing its type settings.
684            *
685            * @param groupId the primary key of the group
686            * @param privateLayout whether the layout is private to the group
687            * @param layoutId the primary key of the layout
688            * @param typeSettings the settings to load the unicode properties object.
689            See {@link com.liferay.portal.kernel.util.UnicodeProperties
690            #fastLoad(String)}.
691            * @return the updated layout
692            */
693            public static com.liferay.portal.model.LayoutSoap updateLayout(
694                    long groupId, boolean privateLayout, long layoutId,
695                    java.lang.String typeSettings) throws RemoteException {
696                    try {
697                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateLayout(groupId,
698                                            privateLayout, layoutId, typeSettings);
699    
700                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
701                    }
702                    catch (Exception e) {
703                            _log.error(e, e);
704    
705                            throw new RemoteException(e.getMessage());
706                    }
707            }
708    
709            /**
710            * Updates the look and feel of the layout.
711            *
712            * @param groupId the primary key of the group
713            * @param privateLayout whether the layout is private to the group
714            * @param layoutId the primary key of the layout
715            * @param themeId the primary key of the layout's new theme
716            * @param colorSchemeId the primary key of the layout's new color scheme
717            * @param css the layout's new CSS
718            * @param wapTheme whether the theme is for WAP browsers
719            * @return the updated layout
720            */
721            public static com.liferay.portal.model.LayoutSoap updateLookAndFeel(
722                    long groupId, boolean privateLayout, long layoutId,
723                    java.lang.String themeId, java.lang.String colorSchemeId,
724                    java.lang.String css, boolean wapTheme) throws RemoteException {
725                    try {
726                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateLookAndFeel(groupId,
727                                            privateLayout, layoutId, themeId, colorSchemeId, css,
728                                            wapTheme);
729    
730                            return com.liferay.portal.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.model.LayoutSoap updateName(long groupId,
752                    boolean privateLayout, long layoutId, java.lang.String name,
753                    java.lang.String languageId) throws RemoteException {
754                    try {
755                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateName(groupId,
756                                            privateLayout, layoutId, name, languageId);
757    
758                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
759                    }
760                    catch (Exception e) {
761                            _log.error(e, e);
762    
763                            throw new RemoteException(e.getMessage());
764                    }
765            }
766    
767            /**
768            * Updates the name of the layout matching the primary key.
769            *
770            * @param plid the primary key of the layout
771            * @param name the name to be assigned
772            * @param languageId the primary key of the language. For more information
773            see {@link Locale}.
774            * @return the updated layout
775            */
776            public static com.liferay.portal.model.LayoutSoap updateName(long plid,
777                    java.lang.String name, java.lang.String languageId)
778                    throws RemoteException {
779                    try {
780                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateName(plid,
781                                            name, languageId);
782    
783                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
784                    }
785                    catch (Exception e) {
786                            _log.error(e, e);
787    
788                            throw new RemoteException(e.getMessage());
789                    }
790            }
791    
792            /**
793            * Updates the parent layout ID of the layout matching the group, layout ID,
794            * and privacy.
795            *
796            * @param groupId the primary key of the group
797            * @param privateLayout whether the layout is private to the group
798            * @param layoutId the primary key of the layout
799            * @param parentLayoutId the primary key to be assigned to the parent
800            layout
801            * @return the matching layout
802            */
803            public static com.liferay.portal.model.LayoutSoap updateParentLayoutId(
804                    long groupId, boolean privateLayout, long layoutId, long parentLayoutId)
805                    throws RemoteException {
806                    try {
807                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateParentLayoutId(groupId,
808                                            privateLayout, layoutId, parentLayoutId);
809    
810                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
811                    }
812                    catch (Exception e) {
813                            _log.error(e, e);
814    
815                            throw new RemoteException(e.getMessage());
816                    }
817            }
818    
819            /**
820            * Updates the parent layout ID of the layout matching the primary key. If a
821            * layout matching the parent primary key is found, the layout ID of that
822            * layout is assigned, otherwise {@link
823            * LayoutConstants#DEFAULT_PARENT_LAYOUT_ID} is assigned.
824            *
825            * @param plid the primary key of the layout
826            * @param parentPlid the primary key of the parent layout
827            * @return the layout matching the primary key
828            */
829            public static com.liferay.portal.model.LayoutSoap updateParentLayoutId(
830                    long plid, long parentPlid) throws RemoteException {
831                    try {
832                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateParentLayoutId(plid,
833                                            parentPlid);
834    
835                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
836                    }
837                    catch (Exception e) {
838                            _log.error(e, e);
839    
840                            throw new RemoteException(e.getMessage());
841                    }
842            }
843    
844            /**
845            * Updates the parent layout ID and priority of the layout.
846            *
847            * @param plid the primary key of the layout
848            * @param parentPlid the primary key of the parent layout
849            * @param priority the layout's new priority
850            * @return the layout matching the primary key
851            */
852            public static com.liferay.portal.model.LayoutSoap updateParentLayoutIdAndPriority(
853                    long plid, long parentPlid, int priority) throws RemoteException {
854                    try {
855                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updateParentLayoutIdAndPriority(plid,
856                                            parentPlid, priority);
857    
858                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
859                    }
860                    catch (Exception e) {
861                            _log.error(e, e);
862    
863                            throw new RemoteException(e.getMessage());
864                    }
865            }
866    
867            /**
868            * Updates the priority of the layout matching the group, layout ID, and
869            * privacy.
870            *
871            * @param groupId the primary key of the group
872            * @param privateLayout whether the layout is private to the group
873            * @param layoutId the primary key of the layout
874            * @param priority the layout's new priority
875            * @return the updated layout
876            */
877            public static com.liferay.portal.model.LayoutSoap updatePriority(
878                    long groupId, boolean privateLayout, long layoutId, int priority)
879                    throws RemoteException {
880                    try {
881                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updatePriority(groupId,
882                                            privateLayout, layoutId, priority);
883    
884                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
885                    }
886                    catch (Exception e) {
887                            _log.error(e, e);
888    
889                            throw new RemoteException(e.getMessage());
890                    }
891            }
892    
893            /**
894            * Updates the priority of the layout matching the group, layout ID, and
895            * privacy, setting the layout's priority based on the priorities of the
896            * next and previous layouts.
897            *
898            * @param groupId the primary key of the group
899            * @param privateLayout whether the layout is private to the group
900            * @param layoutId the primary key of the layout
901            * @param nextLayoutId the primary key of the next layout
902            * @param previousLayoutId the primary key of the previous layout
903            * @return the updated layout
904            */
905            public static com.liferay.portal.model.LayoutSoap updatePriority(
906                    long groupId, boolean privateLayout, long layoutId, long nextLayoutId,
907                    long previousLayoutId) throws RemoteException {
908                    try {
909                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updatePriority(groupId,
910                                            privateLayout, layoutId, nextLayoutId, previousLayoutId);
911    
912                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
913                    }
914                    catch (Exception e) {
915                            _log.error(e, e);
916    
917                            throw new RemoteException(e.getMessage());
918                    }
919            }
920    
921            /**
922            * Updates the priority of the layout matching the primary key.
923            *
924            * @param plid the primary key of the layout
925            * @param priority the layout's new priority
926            * @return the updated layout
927            */
928            public static com.liferay.portal.model.LayoutSoap updatePriority(
929                    long plid, int priority) throws RemoteException {
930                    try {
931                            com.liferay.portal.model.Layout returnValue = LayoutServiceUtil.updatePriority(plid,
932                                            priority);
933    
934                            return com.liferay.portal.model.LayoutSoap.toSoapModel(returnValue);
935                    }
936                    catch (Exception e) {
937                            _log.error(e, e);
938    
939                            throw new RemoteException(e.getMessage());
940                    }
941            }
942    
943            private static Log _log = LogFactoryUtil.getLog(LayoutServiceSoap.class);
944    }