001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.service.http;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.service.GroupServiceUtil;
020    
021    import java.rmi.RemoteException;
022    
023    /**
024     * <p>
025     * This class provides a SOAP utility for the
026     * {@link com.liferay.portal.service.GroupServiceUtil} service utility. The
027     * static methods of this class calls the same methods of the service utility.
028     * However, the signatures are different because it is difficult for SOAP to
029     * support certain types.
030     * </p>
031     *
032     * <p>
033     * ServiceBuilder follows certain rules in translating the methods. For example,
034     * if the method in the service utility returns a {@link java.util.List}, that
035     * is translated to an array of {@link com.liferay.portal.model.GroupSoap}.
036     * If the method in the service utility returns a
037     * {@link com.liferay.portal.model.Group}, that is translated to a
038     * {@link com.liferay.portal.model.GroupSoap}. Methods that SOAP cannot
039     * safely wire are skipped.
040     * </p>
041     *
042     * <p>
043     * The benefits of using the SOAP utility is that it is cross platform
044     * compatible. SOAP allows different languages like Java, .NET, C++, PHP, and
045     * even Perl, to call the generated services. One drawback of SOAP is that it is
046     * slow because it needs to serialize all calls into a text format (XML).
047     * </p>
048     *
049     * <p>
050     * You can see a list of services at
051     * http://localhost:8080/tunnel-web/secure/axis. Set the property
052     * <b>tunnel.servlet.hosts.allowed</b> in portal.properties to configure
053     * security.
054     * </p>
055     *
056     * <p>
057     * The SOAP utility is only generated for remote services.
058     * </p>
059     *
060     * @author    Brian Wing Shun Chan
061     * @see       GroupServiceHttp
062     * @see       com.liferay.portal.model.GroupSoap
063     * @see       com.liferay.portal.service.GroupServiceUtil
064     * @generated
065     */
066    public class GroupServiceSoap {
067            /**
068            * Adds a group.
069            *
070            * @param liveGroupId the primary key of the live group
071            * @param name the entity's name
072            * @param description the group's description (optionally
073            <code>null</code>)
074            * @param type the group's type. For more information see {@link
075            com.liferay.portal.model.GroupConstants}
076            * @param friendlyURL the group's friendlyURL (optionally
077            <code>null</code>)
078            * @param site whether the group is to be associated with a main site
079            * @param active whether the group is active
080            * @param serviceContext the service context to be applied (optionally
081            <code>null</code>). Can specify the group's asset category IDs,
082            asset tag names, and whether the group is for staging
083            * @return the group
084            * @throws PortalException if the user did not have permission to add the
085            group, if a creator could not be found, if the group's
086            information was invalid, if a layout could not be found, or if a
087            valid friendly URL could not be created for the group
088            * @throws SystemException if a system exception occurred
089            */
090            public static com.liferay.portal.model.GroupSoap addGroup(
091                    long liveGroupId, java.lang.String name, java.lang.String description,
092                    int type, java.lang.String friendlyURL, boolean site, boolean active,
093                    com.liferay.portal.service.ServiceContext serviceContext)
094                    throws RemoteException {
095                    try {
096                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.addGroup(liveGroupId,
097                                            name, description, type, friendlyURL, site, active,
098                                            serviceContext);
099    
100                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
101                    }
102                    catch (Exception e) {
103                            _log.error(e, e);
104    
105                            throw new RemoteException(e.getMessage());
106                    }
107            }
108    
109            /**
110            * Adds the group using the group default live group ID.
111            *
112            * @param name the entity's name
113            * @param description the group's description (optionally
114            <code>null</code>)
115            * @param type the group's type. For more information see {@link
116            com.liferay.portal.model.GroupConstants}
117            * @param friendlyURL the group's friendlyURL
118            * @param site whether the group is to be associated with a main site
119            * @param active whether the group is active
120            * @param serviceContext the service context to be applied (optionally
121            <code>null</code>). Can specify the group's asset category IDs,
122            asset tag names, and whether the group is for staging
123            * @return the group
124            * @throws PortalException if the user did not have permission to add the
125            group, if a creator could not be found, if the group's
126            information was invalid, if a layout could not be found, or if a
127            valid friendly URL could not be created for the group
128            * @throws SystemException if a system exception occurred
129            */
130            public static com.liferay.portal.model.GroupSoap addGroup(
131                    java.lang.String name, java.lang.String description, int type,
132                    java.lang.String friendlyURL, boolean site, boolean active,
133                    com.liferay.portal.service.ServiceContext serviceContext)
134                    throws RemoteException {
135                    try {
136                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.addGroup(name,
137                                            description, type, friendlyURL, site, active, serviceContext);
138    
139                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
140                    }
141                    catch (Exception e) {
142                            _log.error(e, e);
143    
144                            throw new RemoteException(e.getMessage());
145                    }
146            }
147    
148            /**
149            * Adds the groups to the role.
150            *
151            * @param roleId the primary key of the role
152            * @param groupIds the primary keys of the groups
153            * @throws PortalException if the user did not have permission to update the
154            role
155            * @throws SystemException if a system exception occurred
156            */
157            public static void addRoleGroups(long roleId, long[] groupIds)
158                    throws RemoteException {
159                    try {
160                            GroupServiceUtil.addRoleGroups(roleId, groupIds);
161                    }
162                    catch (Exception e) {
163                            _log.error(e, e);
164    
165                            throw new RemoteException(e.getMessage());
166                    }
167            }
168    
169            /**
170            * Deletes the group.
171            *
172            * <p>
173            * The group is unstaged and its assets and resources including layouts,
174            * membership requests, subscriptions, teams, blogs, bookmarks, calendar
175            * events, image gallery, journals, message boards, polls, shopping related
176            * entities, software catalog, and wikis are also deleted.
177            * </p>
178            *
179            * @param groupId the primary key of the group
180            * @throws PortalException if the user did not have permission to delete the
181            group or its assets or resources, if a group with the primary key
182            could not be found, or if the group was a system group
183            * @throws SystemException if a system exception occurred
184            */
185            public static void deleteGroup(long groupId) throws RemoteException {
186                    try {
187                            GroupServiceUtil.deleteGroup(groupId);
188                    }
189                    catch (Exception e) {
190                            _log.error(e, e);
191    
192                            throw new RemoteException(e.getMessage());
193                    }
194            }
195    
196            /**
197            * Returns the group with the primary key.
198            *
199            * @param groupId the primary key of the group
200            * @return the group with the primary key
201            * @throws PortalException if a group with the primary key could not be
202            found or if the current user did not have permission to view the
203            group
204            * @throws SystemException if a system exception occurred
205            */
206            public static com.liferay.portal.model.GroupSoap getGroup(long groupId)
207                    throws RemoteException {
208                    try {
209                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.getGroup(groupId);
210    
211                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
212                    }
213                    catch (Exception e) {
214                            _log.error(e, e);
215    
216                            throw new RemoteException(e.getMessage());
217                    }
218            }
219    
220            /**
221            * Returns the group with the name.
222            *
223            * @param companyId the primary key of the company
224            * @param name the group's name
225            * @return the group with the name
226            * @throws PortalException if a matching group could not be found or if the
227            current user did not have permission to view the group
228            * @throws SystemException if a system exception occurred
229            */
230            public static com.liferay.portal.model.GroupSoap getGroup(long companyId,
231                    java.lang.String name) throws RemoteException {
232                    try {
233                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.getGroup(companyId,
234                                            name);
235    
236                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
237                    }
238                    catch (Exception e) {
239                            _log.error(e, e);
240    
241                            throw new RemoteException(e.getMessage());
242                    }
243            }
244    
245            /**
246            * Returns a range of all the site groups for which the user has control
247            * panel access.
248            *
249            * @param portlets the portlets to manage
250            * @param max the upper bound of the range of groups to consider (not
251            inclusive)
252            * @return the range of site groups for which the user has control panel
253            access
254            * @throws PortalException if a portal exception occurred
255            * @throws SystemException if a system exception occurred
256            */
257            public static com.liferay.portal.model.GroupSoap[] getManageableSites(
258                    java.util.Collection<com.liferay.portal.model.Portlet> portlets, int max)
259                    throws RemoteException {
260                    try {
261                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getManageableSites(portlets,
262                                            max);
263    
264                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
265                    }
266                    catch (Exception e) {
267                            _log.error(e, e);
268    
269                            throw new RemoteException(e.getMessage());
270                    }
271            }
272    
273            /**
274            * Returns the groups associated with the organizations.
275            *
276            * @param organizations the organizations
277            * @return the groups associated with the organizations
278            * @throws PortalException if a portal exception occurred
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portal.model.GroupSoap[] getOrganizationsGroups(
282                    com.liferay.portal.model.OrganizationSoap[] organizations)
283                    throws RemoteException {
284                    try {
285                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getOrganizationsGroups(com.liferay.portal.model.impl.OrganizationModelImpl.toModels(
286                                                    organizations));
287    
288                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
289                    }
290                    catch (Exception e) {
291                            _log.error(e, e);
292    
293                            throw new RemoteException(e.getMessage());
294                    }
295            }
296    
297            /**
298            * Returns the group associated with the user.
299            *
300            * @param companyId the primary key of the company
301            * @param userId the primary key of the user
302            * @return the group associated with the user
303            * @throws PortalException if a matching group could not be found or if the
304            current user did not have permission to view the group
305            * @throws SystemException if a system exception occurred
306            */
307            public static com.liferay.portal.model.GroupSoap getUserGroup(
308                    long companyId, long userId) throws RemoteException {
309                    try {
310                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.getUserGroup(companyId,
311                                            userId);
312    
313                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
314                    }
315                    catch (Exception e) {
316                            _log.error(e, e);
317    
318                            throw new RemoteException(e.getMessage());
319                    }
320            }
321    
322            /**
323            * Returns the groups associated with the user groups.
324            *
325            * @param userGroups the user groups
326            * @return the groups associated with the user groups
327            * @throws PortalException if any one of the user group's group could not be
328            found
329            * @throws SystemException if a system exception occurred
330            */
331            public static com.liferay.portal.model.GroupSoap[] getUserGroupsGroups(
332                    com.liferay.portal.model.UserGroupSoap[] userGroups)
333                    throws RemoteException {
334                    try {
335                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getUserGroupsGroups(com.liferay.portal.model.impl.UserGroupModelImpl.toModels(
336                                                    userGroups));
337    
338                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
339                    }
340                    catch (Exception e) {
341                            _log.error(e, e);
342    
343                            throw new RemoteException(e.getMessage());
344                    }
345            }
346    
347            /**
348            * Returns the range of all groups associated with the user's organization
349            * groups, including the ancestors of the organization groups, unless portal
350            * property <code>organizations.membership.strict</code> is set to
351            * <code>true</code>.
352            *
353            * <p>
354            * Useful when paginating results. Returns a maximum of <code>end -
355            * start</code> instances. <code>start</code> and <code>end</code> are not
356            * primary keys, they are indexes in the result set. Thus, <code>0</code>
357            * refers to the first result in the set. Setting both <code>start</code>
358            * and <code>end</code> to {@link
359            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
360            * result set.
361            * </p>
362            *
363            * @param userId the primary key of the user
364            * @param start the lower bound of the range of groups to consider
365            * @param end the upper bound of the range of groups to consider (not
366            inclusive)
367            * @return the range of groups associated with the user's organizations
368            * @throws PortalException if a user with the primary key could not be found
369            or if another portal exception occurred
370            * @throws SystemException if a system exception occurred
371            */
372            public static com.liferay.portal.model.GroupSoap[] getUserOrganizationsGroups(
373                    long userId, int start, int end) throws RemoteException {
374                    try {
375                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getUserOrganizationsGroups(userId,
376                                            start, end);
377    
378                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
379                    }
380                    catch (Exception e) {
381                            _log.error(e, e);
382    
383                            throw new RemoteException(e.getMessage());
384                    }
385            }
386    
387            /**
388            * Returns the guest or current user's layout set group, organization
389            * groups, inherited organization groups, and site groups.
390            *
391            * @return the user's layout set group, organization groups, and inherited
392            organization groups, and site groups
393            * @throws PortalException if a portal exception occurred
394            * @throws SystemException if a system exception occurred
395            */
396            public static com.liferay.portal.model.GroupSoap[] getUserSites()
397                    throws RemoteException {
398                    try {
399                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getUserSites();
400    
401                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
402                    }
403                    catch (Exception e) {
404                            _log.error(e, e);
405    
406                            throw new RemoteException(e.getMessage());
407                    }
408            }
409    
410            /**
411            * Returns the guest or current user's group &quot;places&quot; associated
412            * with the group entity class names, including the control panel group if
413            * the user is permitted to view the control panel.
414            *
415            * <p>
416            * <ul> <li> Class name &quot;User&quot; includes the user's layout set
417            * group. </li> <li> Class name &quot;Organization&quot; includes the user's
418            * immediate organization groups and inherited organization groups. </li>
419            * <li> Class name &quot;Group&quot; includes the user's immediate
420            * organization groups and site groups. </li> <li> A <code>classNames</code>
421            * value of <code>null</code> includes the user's layout set group,
422            * organization groups, inherited organization groups, and site groups.
423            * </li> </ul>
424            * </p>
425            *
426            * @param classNames the group entity class names (optionally
427            <code>null</code>). For more information see {@link
428            #getUserPlaces(String[], int)}
429            * @param max the maximum number of groups to return
430            * @return the user's group &quot;places&quot;
431            * @throws PortalException if a portal exception occurred
432            * @throws SystemException if a system exception occurred
433            */
434            public static com.liferay.portal.model.GroupSoap[] getUserPlaces(
435                    java.lang.String[] classNames, int max) throws RemoteException {
436                    try {
437                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getUserPlaces(classNames,
438                                            max);
439    
440                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
441                    }
442                    catch (Exception e) {
443                            _log.error(e, e);
444    
445                            throw new RemoteException(e.getMessage());
446                    }
447            }
448    
449            /**
450            * Returns the user's group &quot;places&quot; associated with the group
451            * entity class names, including the control panel group if the user is
452            * permitted to view the control panel.
453            *
454            * <p>
455            * <ul> <li> Class name &quot;User&quot; includes the user's layout set
456            * group. </li> <li> Class name &quot;Organization&quot; includes the user's
457            * immediate organization groups and inherited organization groups. </li>
458            * <li> Class name &quot;Group&quot; includes the user's immediate
459            * organization groups and site groups. </li> <li> A <code>classNames</code>
460            * value of <code>null</code> includes the user's layout set group,
461            * organization groups, inherited organization groups, and site groups.
462            * </li> </ul>
463            * </p>
464            *
465            * @param userId the primary key of the user
466            * @param classNames the group entity class names (optionally
467            <code>null</code>). For more information see {@link
468            #getUserPlaces(long, String[], int)}
469            * @param max the maximum number of groups to return
470            * @return the user's group &quot;places&quot;
471            * @throws PortalException if a portal exception occurred
472            * @throws SystemException if a system exception occurred
473            */
474            public static com.liferay.portal.model.GroupSoap[] getUserPlaces(
475                    long userId, java.lang.String[] classNames, int max)
476                    throws RemoteException {
477                    try {
478                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.getUserPlaces(userId,
479                                            classNames, max);
480    
481                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
482                    }
483                    catch (Exception e) {
484                            _log.error(e, e);
485    
486                            throw new RemoteException(e.getMessage());
487                    }
488            }
489    
490            /**
491            * Returns <code>true</code> if the user is associated with the group,
492            * including the user's inherited organizations and user groups. System and
493            * staged groups are not included.
494            *
495            * @param userId the primary key of the user
496            * @param groupId the primary key of the group
497            * @return <code>true</code> if the user is associated with the group;
498            <code>false</code> otherwise
499            * @throws SystemException if a system exception occurred
500            */
501            public static boolean hasUserGroup(long userId, long groupId)
502                    throws RemoteException {
503                    try {
504                            boolean returnValue = GroupServiceUtil.hasUserGroup(userId, groupId);
505    
506                            return returnValue;
507                    }
508                    catch (Exception e) {
509                            _log.error(e, e);
510    
511                            throw new RemoteException(e.getMessage());
512                    }
513            }
514    
515            /**
516            * Returns a name ordered range of all the site groups and organization
517            * groups that match the name and description, optionally including the
518            * user's inherited organization groups and user groups. System and staged
519            * groups are not included.
520            *
521            * <p>
522            * Useful when paginating results. Returns a maximum of <code>end -
523            * start</code> instances. <code>start</code> and <code>end</code> are not
524            * primary keys, they are indexes in the result set. Thus, <code>0</code>
525            * refers to the first result in the set. Setting both <code>start</code>
526            * and <code>end</code> to {@link
527            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
528            * result set.
529            * </p>
530            *
531            * @param companyId the primary key of the company
532            * @param name the group's name (optionally <code>null</code>)
533            * @param description the group's description (optionally
534            <code>null</code>)
535            * @param params the finder params (optionally <code>null</code>). To
536            include the user's inherited organizations and user groups in the
537            search, add entries having &quot;usersGroups&quot; and
538            &quot;inherit&quot; as keys mapped to the the user's ID. For more
539            information see {@link
540            com.liferay.portal.service.persistence.GroupFinder}
541            * @param start the lower bound of the range of groups to return
542            * @param end the upper bound of the range of groups to return (not
543            inclusive)
544            * @return the matching groups ordered by name
545            * @throws PortalException if a portal exception occurred
546            * @throws SystemException if a system exception occurred
547            */
548            public static com.liferay.portal.model.GroupSoap[] search(long companyId,
549                    java.lang.String name, java.lang.String description,
550                    java.lang.String[] params, int start, int end)
551                    throws RemoteException {
552                    try {
553                            java.util.List<com.liferay.portal.model.Group> returnValue = GroupServiceUtil.search(companyId,
554                                            name, description, params, start, end);
555    
556                            return com.liferay.portal.model.GroupSoap.toSoapModels(returnValue);
557                    }
558                    catch (Exception e) {
559                            _log.error(e, e);
560    
561                            throw new RemoteException(e.getMessage());
562                    }
563            }
564    
565            /**
566            * Returns the number of groups and organization groups that match the name
567            * and description, optionally including the user's inherited organizations
568            * and user groups. System and staged groups are not included.
569            *
570            * @param companyId the primary key of the company
571            * @param name the group's name (optionally <code>null</code>)
572            * @param description the group's description (optionally
573            <code>null</code>)
574            * @param params the finder params (optionally <code>null</code>). To
575            include the user's inherited organizations and user groups in the
576            search, add entries having &quot;usersGroups&quot; and
577            &quot;inherit&quot; as keys mapped to the the user's ID. For more
578            information see {@link
579            com.liferay.portal.service.persistence.GroupFinder}
580            * @return the number of matching groups
581            * @throws SystemException if a system exception occurred
582            */
583            public static int searchCount(long companyId, java.lang.String name,
584                    java.lang.String description, java.lang.String[] params)
585                    throws RemoteException {
586                    try {
587                            int returnValue = GroupServiceUtil.searchCount(companyId, name,
588                                            description, params);
589    
590                            return returnValue;
591                    }
592                    catch (Exception e) {
593                            _log.error(e, e);
594    
595                            throw new RemoteException(e.getMessage());
596                    }
597            }
598    
599            /**
600            * Sets the groups associated with the role, removing and adding
601            * associations as necessary.
602            *
603            * @param roleId the primary key of the role
604            * @param groupIds the primary keys of the groups
605            * @throws PortalException if the user did not have permission to update
606            update the role
607            * @throws SystemException if a system exception occurred
608            */
609            public static void setRoleGroups(long roleId, long[] groupIds)
610                    throws RemoteException {
611                    try {
612                            GroupServiceUtil.setRoleGroups(roleId, groupIds);
613                    }
614                    catch (Exception e) {
615                            _log.error(e, e);
616    
617                            throw new RemoteException(e.getMessage());
618                    }
619            }
620    
621            /**
622            * Removes the groups from the role.
623            *
624            * @param roleId the primary key of the role
625            * @param groupIds the primary keys of the groups
626            * @throws PortalException if the user did not have permission to update the
627            role
628            * @throws SystemException if a system exception occurred
629            */
630            public static void unsetRoleGroups(long roleId, long[] groupIds)
631                    throws RemoteException {
632                    try {
633                            GroupServiceUtil.unsetRoleGroups(roleId, groupIds);
634                    }
635                    catch (Exception e) {
636                            _log.error(e, e);
637    
638                            throw new RemoteException(e.getMessage());
639                    }
640            }
641    
642            /**
643            * Updates the group's friendly URL.
644            *
645            * @param groupId the primary key of the group
646            * @param friendlyURL the group's new friendlyURL (optionally
647            <code>null</code>)
648            * @return the group
649            * @throws PortalException if the user did not have permission to update the
650            group, if a group with the primary key could not be found, or if
651            a valid friendly URL could not be created for the group
652            * @throws SystemException if a system exception occurred
653            */
654            public static com.liferay.portal.model.GroupSoap updateFriendlyURL(
655                    long groupId, java.lang.String friendlyURL) throws RemoteException {
656                    try {
657                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.updateFriendlyURL(groupId,
658                                            friendlyURL);
659    
660                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
661                    }
662                    catch (Exception e) {
663                            _log.error(e, e);
664    
665                            throw new RemoteException(e.getMessage());
666                    }
667            }
668    
669            /**
670            * Updates the group's type settings.
671            *
672            * @param groupId the primary key of the group
673            * @param typeSettings the group's new type settings (optionally
674            <code>null</code>)
675            * @return the group
676            * @throws PortalException if the user did not have permission to update the
677            group or if a group with the primary key could not be found
678            * @throws SystemException if a system exception occurred
679            */
680            public static com.liferay.portal.model.GroupSoap updateGroup(long groupId,
681                    java.lang.String typeSettings) throws RemoteException {
682                    try {
683                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.updateGroup(groupId,
684                                            typeSettings);
685    
686                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
687                    }
688                    catch (Exception e) {
689                            _log.error(e, e);
690    
691                            throw new RemoteException(e.getMessage());
692                    }
693            }
694    
695            /**
696            * Updates the group.
697            *
698            * @param groupId the primary key of the group
699            * @param name the group's new name
700            * @param description the group's new description (optionally
701            <code>null</code>)
702            * @param type the group's new type. For more information see {@link
703            com.liferay.portal.model.GroupConstants}
704            * @param friendlyURL the group's new friendlyURL (optionally
705            <code>null</code>)
706            * @param active whether the group is active
707            * @param serviceContext the service context to be applied (optionally
708            <code>null</code>). Can specify the group's replacement asset
709            category IDs and replacement asset tag names
710            * @return the group
711            * @throws PortalException if the user did not have permission to update the
712            group, if a group with the primary key could not be found, if the
713            friendly URL was invalid or could one not be created
714            * @throws SystemException if a system exception occurred
715            */
716            public static com.liferay.portal.model.GroupSoap updateGroup(long groupId,
717                    java.lang.String name, java.lang.String description, int type,
718                    java.lang.String friendlyURL, boolean active,
719                    com.liferay.portal.service.ServiceContext serviceContext)
720                    throws RemoteException {
721                    try {
722                            com.liferay.portal.model.Group returnValue = GroupServiceUtil.updateGroup(groupId,
723                                            name, description, type, friendlyURL, active, serviceContext);
724    
725                            return com.liferay.portal.model.GroupSoap.toSoapModel(returnValue);
726                    }
727                    catch (Exception e) {
728                            _log.error(e, e);
729    
730                            throw new RemoteException(e.getMessage());
731                    }
732            }
733    
734            private static Log _log = LogFactoryUtil.getLog(GroupServiceSoap.class);
735    }