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.LocaleUtil;
022    import com.liferay.portal.service.UserServiceUtil;
023    
024    import java.rmi.RemoteException;
025    
026    /**
027     * Provides the SOAP utility for the
028     * {@link com.liferay.portal.service.UserServiceUtil} service utility. The
029     * static methods of this class calls the same methods of the service utility.
030     * However, the signatures are different because it is difficult for SOAP to
031     * support certain types.
032     *
033     * <p>
034     * ServiceBuilder follows certain rules in translating the methods. For example,
035     * if the method in the service utility returns a {@link java.util.List}, that
036     * is translated to an array of {@link com.liferay.portal.model.UserSoap}.
037     * If the method in the service utility returns a
038     * {@link com.liferay.portal.model.User}, that is translated to a
039     * {@link com.liferay.portal.model.UserSoap}. Methods that SOAP cannot
040     * safely wire are skipped.
041     * </p>
042     *
043     * <p>
044     * The benefits of using the SOAP utility is that it is cross platform
045     * compatible. SOAP allows different languages like Java, .NET, C++, PHP, and
046     * even Perl, to call the generated services. One drawback of SOAP is that it is
047     * slow because it needs to serialize all calls into a text format (XML).
048     * </p>
049     *
050     * <p>
051     * You can see a list of services at http://localhost:8080/api/axis. Set the
052     * property <b>axis.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 UserServiceHttp
062     * @see com.liferay.portal.model.UserSoap
063     * @see com.liferay.portal.service.UserServiceUtil
064     * @generated
065     */
066    @ProviderType
067    public class UserServiceSoap {
068            /**
069            * Adds the users to the group.
070            *
071            * @param groupId the primary key of the group
072            * @param userIds the primary keys of the users
073            * @param serviceContext the service context to be applied (optionally
074            <code>null</code>)
075            * @throws PortalException if a group or user with the primary key could not
076            be found, if the user did not have permission to assign group
077            members, or if the operation was not allowed by the membership
078            policy
079            */
080            public static void addGroupUsers(long groupId, long[] userIds,
081                    com.liferay.portal.service.ServiceContext serviceContext)
082                    throws RemoteException {
083                    try {
084                            UserServiceUtil.addGroupUsers(groupId, userIds, serviceContext);
085                    }
086                    catch (Exception e) {
087                            _log.error(e, e);
088    
089                            throw new RemoteException(e.getMessage());
090                    }
091            }
092    
093            /**
094            * Adds the users to the organization.
095            *
096            * @param organizationId the primary key of the organization
097            * @param userIds the primary keys of the users
098            * @throws PortalException if an organization or user with the primary key
099            could not be found, if the user did not have permission to assign
100            organization members, if current user did not have an
101            organization in common with a given user, or if the operation was
102            not allowed by the membership policy
103            */
104            public static void addOrganizationUsers(long organizationId, long[] userIds)
105                    throws RemoteException {
106                    try {
107                            UserServiceUtil.addOrganizationUsers(organizationId, userIds);
108                    }
109                    catch (Exception e) {
110                            _log.error(e, e);
111    
112                            throw new RemoteException(e.getMessage());
113                    }
114            }
115    
116            /**
117            * Assigns the password policy to the users, removing any other currently
118            * assigned password policies.
119            *
120            * @param passwordPolicyId the primary key of the password policy
121            * @param userIds the primary keys of the users
122            * @throws PortalException if the user did not have permission to assign
123            policy members
124            */
125            public static void addPasswordPolicyUsers(long passwordPolicyId,
126                    long[] userIds) throws RemoteException {
127                    try {
128                            UserServiceUtil.addPasswordPolicyUsers(passwordPolicyId, userIds);
129                    }
130                    catch (Exception e) {
131                            _log.error(e, e);
132    
133                            throw new RemoteException(e.getMessage());
134                    }
135            }
136    
137            /**
138            * Adds the users to the role.
139            *
140            * @param roleId the primary key of the role
141            * @param userIds the primary keys of the users
142            * @throws PortalException if a role or user with the primary key could not
143            be found, if the user did not have permission to assign role
144            members, or if the operation was not allowed by the membership
145            policy
146            */
147            public static void addRoleUsers(long roleId, long[] userIds)
148                    throws RemoteException {
149                    try {
150                            UserServiceUtil.addRoleUsers(roleId, userIds);
151                    }
152                    catch (Exception e) {
153                            _log.error(e, e);
154    
155                            throw new RemoteException(e.getMessage());
156                    }
157            }
158    
159            /**
160            * Adds the users to the team.
161            *
162            * @param teamId the primary key of the team
163            * @param userIds the primary keys of the users
164            * @throws PortalException if a team or user with the primary key could not
165            be found or if the user did not have permission to assign team
166            members
167            */
168            public static void addTeamUsers(long teamId, long[] userIds)
169                    throws RemoteException {
170                    try {
171                            UserServiceUtil.addTeamUsers(teamId, userIds);
172                    }
173                    catch (Exception e) {
174                            _log.error(e, e);
175    
176                            throw new RemoteException(e.getMessage());
177                    }
178            }
179    
180            /**
181            * Adds a user.
182            *
183            * <p>
184            * This method handles the creation and bookkeeping of the user including
185            * its resources, metadata, and internal data structures. It is not
186            * necessary to make subsequent calls to any methods to setup default
187            * groups, resources, etc.
188            * </p>
189            *
190            * @param companyId the primary key of the user's company
191            * @param autoPassword whether a password should be automatically generated
192            for the user
193            * @param password1 the user's password
194            * @param password2 the user's password confirmation
195            * @param autoScreenName whether a screen name should be automatically
196            generated for the user
197            * @param screenName the user's screen name
198            * @param emailAddress the user's email address
199            * @param facebookId the user's facebook ID
200            * @param openId the user's OpenID
201            * @param locale the user's locale
202            * @param firstName the user's first name
203            * @param middleName the user's middle name
204            * @param lastName the user's last name
205            * @param prefixId the user's name prefix ID
206            * @param suffixId the user's name suffix ID
207            * @param male whether the user is male
208            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
209            January)
210            * @param birthdayDay the user's birthday day
211            * @param birthdayYear the user's birthday year
212            * @param jobTitle the user's job title
213            * @param groupIds the primary keys of the user's groups
214            * @param organizationIds the primary keys of the user's organizations
215            * @param roleIds the primary keys of the roles this user possesses
216            * @param userGroupIds the primary keys of the user's user groups
217            * @param sendEmail whether to send the user an email notification about
218            their new account
219            * @param serviceContext the service context to be applied (optionally
220            <code>null</code>). Can set the UUID (with the <code>uuid</code>
221            attribute), asset category IDs, asset tag names, and expando
222            bridge attributes for the user.
223            * @return the new user
224            * @throws PortalException if the user's information was invalid, if the
225            operation was not allowed by the membership policy, if the
226            creator did not have permission to add users, or if the email
227            address was reserved
228            */
229            public static com.liferay.portal.model.UserSoap addUser(long companyId,
230                    boolean autoPassword, java.lang.String password1,
231                    java.lang.String password2, boolean autoScreenName,
232                    java.lang.String screenName, java.lang.String emailAddress,
233                    long facebookId, java.lang.String openId, String locale,
234                    java.lang.String firstName, java.lang.String middleName,
235                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
236                    int birthdayMonth, int birthdayDay, int birthdayYear,
237                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
238                    long[] roleIds, long[] userGroupIds, boolean sendEmail,
239                    com.liferay.portal.service.ServiceContext serviceContext)
240                    throws RemoteException {
241                    try {
242                            com.liferay.portal.model.User returnValue = UserServiceUtil.addUser(companyId,
243                                            autoPassword, password1, password2, autoScreenName,
244                                            screenName, emailAddress, facebookId, openId,
245                                            LocaleUtil.fromLanguageId(locale), firstName, middleName,
246                                            lastName, prefixId, suffixId, male, birthdayMonth,
247                                            birthdayDay, birthdayYear, jobTitle, groupIds,
248                                            organizationIds, roleIds, userGroupIds, sendEmail,
249                                            serviceContext);
250    
251                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
252                    }
253                    catch (Exception e) {
254                            _log.error(e, e);
255    
256                            throw new RemoteException(e.getMessage());
257                    }
258            }
259    
260            /**
261            * Adds a user with additional parameters.
262            *
263            * <p>
264            * This method handles the creation and bookkeeping of the user including
265            * its resources, metadata, and internal data structures. It is not
266            * necessary to make subsequent calls to any methods to setup default
267            * groups, resources, etc.
268            * </p>
269            *
270            * @param companyId the primary key of the user's company
271            * @param autoPassword whether a password should be automatically generated
272            for the user
273            * @param password1 the user's password
274            * @param password2 the user's password confirmation
275            * @param autoScreenName whether a screen name should be automatically
276            generated for the user
277            * @param screenName the user's screen name
278            * @param emailAddress the user's email address
279            * @param facebookId the user's facebook ID
280            * @param openId the user's OpenID
281            * @param locale the user's locale
282            * @param firstName the user's first name
283            * @param middleName the user's middle name
284            * @param lastName the user's last name
285            * @param prefixId the user's name prefix ID
286            * @param suffixId the user's name suffix ID
287            * @param male whether the user is male
288            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
289            January)
290            * @param birthdayDay the user's birthday day
291            * @param birthdayYear the user's birthday year
292            * @param jobTitle the user's job title
293            * @param groupIds the primary keys of the user's groups
294            * @param organizationIds the primary keys of the user's organizations
295            * @param roleIds the primary keys of the roles this user possesses
296            * @param userGroupIds the primary keys of the user's user groups
297            * @param addresses the user's addresses
298            * @param emailAddresses the user's email addresses
299            * @param phones the user's phone numbers
300            * @param websites the user's websites
301            * @param announcementsDelivers the announcements deliveries
302            * @param sendEmail whether to send the user an email notification about
303            their new account
304            * @param serviceContext the service context to be applied (optionally
305            <code>null</code>). Can set the UUID (with the <code>uuid</code>
306            attribute), asset category IDs, asset tag names, and expando
307            bridge attributes for the user.
308            * @return the new user
309            * @throws PortalException if the user's information was invalid, if the
310            creator did not have permission to add users, if the email
311            address was reserved, if the operation was not allowed by the
312            membership policy, or if some other portal exception occurred
313            */
314            public static com.liferay.portal.model.UserSoap addUser(long companyId,
315                    boolean autoPassword, java.lang.String password1,
316                    java.lang.String password2, boolean autoScreenName,
317                    java.lang.String screenName, java.lang.String emailAddress,
318                    long facebookId, java.lang.String openId, String locale,
319                    java.lang.String firstName, java.lang.String middleName,
320                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
321                    int birthdayMonth, int birthdayDay, int birthdayYear,
322                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
323                    long[] roleIds, long[] userGroupIds,
324                    com.liferay.portal.model.AddressSoap[] addresses,
325                    com.liferay.portal.model.EmailAddressSoap[] emailAddresses,
326                    com.liferay.portal.model.PhoneSoap[] phones,
327                    com.liferay.portal.model.WebsiteSoap[] websites,
328                    com.liferay.portlet.announcements.model.AnnouncementsDeliverySoap[] announcementsDelivers,
329                    boolean sendEmail,
330                    com.liferay.portal.service.ServiceContext serviceContext)
331                    throws RemoteException {
332                    try {
333                            com.liferay.portal.model.User returnValue = UserServiceUtil.addUser(companyId,
334                                            autoPassword, password1, password2, autoScreenName,
335                                            screenName, emailAddress, facebookId, openId,
336                                            LocaleUtil.fromLanguageId(locale), firstName, middleName,
337                                            lastName, prefixId, suffixId, male, birthdayMonth,
338                                            birthdayDay, birthdayYear, jobTitle, groupIds,
339                                            organizationIds, roleIds, userGroupIds,
340                                            com.liferay.portal.model.impl.AddressModelImpl.toModels(
341                                                    addresses),
342                                            com.liferay.portal.model.impl.EmailAddressModelImpl.toModels(
343                                                    emailAddresses),
344                                            com.liferay.portal.model.impl.PhoneModelImpl.toModels(
345                                                    phones),
346                                            com.liferay.portal.model.impl.WebsiteModelImpl.toModels(
347                                                    websites),
348                                            com.liferay.portlet.announcements.model.impl.AnnouncementsDeliveryModelImpl.toModels(
349                                                    announcementsDelivers), sendEmail, serviceContext);
350    
351                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
352                    }
353                    catch (Exception e) {
354                            _log.error(e, e);
355    
356                            throw new RemoteException(e.getMessage());
357                    }
358            }
359    
360            /**
361            * Adds the users to the user group.
362            *
363            * @param userGroupId the primary key of the user group
364            * @param userIds the primary keys of the users
365            * @throws PortalException if a user group or user with the primary could
366            could not be found, if the current user did not have permission
367            to assign group members, or if the operation was not allowed by
368            the membership policy
369            */
370            public static void addUserGroupUsers(long userGroupId, long[] userIds)
371                    throws RemoteException {
372                    try {
373                            UserServiceUtil.addUserGroupUsers(userGroupId, userIds);
374                    }
375                    catch (Exception e) {
376                            _log.error(e, e);
377    
378                            throw new RemoteException(e.getMessage());
379                    }
380            }
381    
382            /**
383            * Adds a user with workflow.
384            *
385            * <p>
386            * This method handles the creation and bookkeeping of the user including
387            * its resources, metadata, and internal data structures. It is not
388            * necessary to make subsequent calls to any methods to setup default
389            * groups, resources, etc.
390            * </p>
391            *
392            * @param companyId the primary key of the user's company
393            * @param autoPassword whether a password should be automatically generated
394            for the user
395            * @param password1 the user's password
396            * @param password2 the user's password confirmation
397            * @param autoScreenName whether a screen name should be automatically
398            generated for the user
399            * @param screenName the user's screen name
400            * @param emailAddress the user's email address
401            * @param facebookId the user's facebook ID
402            * @param openId the user's OpenID
403            * @param locale the user's locale
404            * @param firstName the user's first name
405            * @param middleName the user's middle name
406            * @param lastName the user's last name
407            * @param prefixId the user's name prefix ID
408            * @param suffixId the user's name suffix ID
409            * @param male whether the user is male
410            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
411            January)
412            * @param birthdayDay the user's birthday day
413            * @param birthdayYear the user's birthday year
414            * @param jobTitle the user's job title
415            * @param groupIds the primary keys of the user's groups
416            * @param organizationIds the primary keys of the user's organizations
417            * @param roleIds the primary keys of the roles this user possesses
418            * @param userGroupIds the primary keys of the user's user groups
419            * @param sendEmail whether to send the user an email notification about
420            their new account
421            * @param serviceContext the service context to be applied (optionally
422            <code>null</code>). Can set the UUID (with the <code>uuid</code>
423            attribute), asset category IDs, asset tag names, and expando
424            bridge attributes for the user.
425            * @return the new user
426            * @throws PortalException if the user's information was invalid, if the
427            operation was not allowed by the membership policy, if the
428            creator did not have permission to add users, or if the email
429            address was reserved
430            */
431            public static com.liferay.portal.model.UserSoap addUserWithWorkflow(
432                    long companyId, boolean autoPassword, java.lang.String password1,
433                    java.lang.String password2, boolean autoScreenName,
434                    java.lang.String screenName, java.lang.String emailAddress,
435                    long facebookId, java.lang.String openId, String locale,
436                    java.lang.String firstName, java.lang.String middleName,
437                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
438                    int birthdayMonth, int birthdayDay, int birthdayYear,
439                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
440                    long[] roleIds, long[] userGroupIds, boolean sendEmail,
441                    com.liferay.portal.service.ServiceContext serviceContext)
442                    throws RemoteException {
443                    try {
444                            com.liferay.portal.model.User returnValue = UserServiceUtil.addUserWithWorkflow(companyId,
445                                            autoPassword, password1, password2, autoScreenName,
446                                            screenName, emailAddress, facebookId, openId,
447                                            LocaleUtil.fromLanguageId(locale), firstName, middleName,
448                                            lastName, prefixId, suffixId, male, birthdayMonth,
449                                            birthdayDay, birthdayYear, jobTitle, groupIds,
450                                            organizationIds, roleIds, userGroupIds, sendEmail,
451                                            serviceContext);
452    
453                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
454                    }
455                    catch (Exception e) {
456                            _log.error(e, e);
457    
458                            throw new RemoteException(e.getMessage());
459                    }
460            }
461    
462            /**
463            * Adds a user with workflow and additional parameters.
464            *
465            * <p>
466            * This method handles the creation and bookkeeping of the user including
467            * its resources, metadata, and internal data structures. It is not
468            * necessary to make subsequent calls to any methods to setup default
469            * groups, resources, etc.
470            * </p>
471            *
472            * @param companyId the primary key of the user's company
473            * @param autoPassword whether a password should be automatically generated
474            for the user
475            * @param password1 the user's password
476            * @param password2 the user's password confirmation
477            * @param autoScreenName whether a screen name should be automatically
478            generated for the user
479            * @param screenName the user's screen name
480            * @param emailAddress the user's email address
481            * @param facebookId the user's facebook ID
482            * @param openId the user's OpenID
483            * @param locale the user's locale
484            * @param firstName the user's first name
485            * @param middleName the user's middle name
486            * @param lastName the user's last name
487            * @param prefixId the user's name prefix ID
488            * @param suffixId the user's name suffix ID
489            * @param male whether the user is male
490            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
491            January)
492            * @param birthdayDay the user's birthday day
493            * @param birthdayYear the user's birthday year
494            * @param jobTitle the user's job title
495            * @param groupIds the primary keys of the user's groups
496            * @param organizationIds the primary keys of the user's organizations
497            * @param roleIds the primary keys of the roles this user possesses
498            * @param userGroupIds the primary keys of the user's user groups
499            * @param addresses the user's addresses
500            * @param emailAddresses the user's email addresses
501            * @param phones the user's phone numbers
502            * @param websites the user's websites
503            * @param announcementsDelivers the announcements deliveries
504            * @param sendEmail whether to send the user an email notification about
505            their new account
506            * @param serviceContext the service context to be applied (optionally
507            <code>null</code>). Can set the UUID (with the <code>uuid</code>
508            attribute), asset category IDs, asset tag names, and expando
509            bridge attributes for the user.
510            * @return the new user
511            * @throws PortalException if the user's information was invalid, if the
512            operation was not allowed by the membership policy, if the
513            creator did not have permission to add users, if the email
514            address was reserved, or if some other portal exception occurred
515            */
516            public static com.liferay.portal.model.UserSoap addUserWithWorkflow(
517                    long companyId, boolean autoPassword, java.lang.String password1,
518                    java.lang.String password2, boolean autoScreenName,
519                    java.lang.String screenName, java.lang.String emailAddress,
520                    long facebookId, java.lang.String openId, String locale,
521                    java.lang.String firstName, java.lang.String middleName,
522                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
523                    int birthdayMonth, int birthdayDay, int birthdayYear,
524                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
525                    long[] roleIds, long[] userGroupIds,
526                    com.liferay.portal.model.AddressSoap[] addresses,
527                    com.liferay.portal.model.EmailAddressSoap[] emailAddresses,
528                    com.liferay.portal.model.PhoneSoap[] phones,
529                    com.liferay.portal.model.WebsiteSoap[] websites,
530                    com.liferay.portlet.announcements.model.AnnouncementsDeliverySoap[] announcementsDelivers,
531                    boolean sendEmail,
532                    com.liferay.portal.service.ServiceContext serviceContext)
533                    throws RemoteException {
534                    try {
535                            com.liferay.portal.model.User returnValue = UserServiceUtil.addUserWithWorkflow(companyId,
536                                            autoPassword, password1, password2, autoScreenName,
537                                            screenName, emailAddress, facebookId, openId,
538                                            LocaleUtil.fromLanguageId(locale), firstName, middleName,
539                                            lastName, prefixId, suffixId, male, birthdayMonth,
540                                            birthdayDay, birthdayYear, jobTitle, groupIds,
541                                            organizationIds, roleIds, userGroupIds,
542                                            com.liferay.portal.model.impl.AddressModelImpl.toModels(
543                                                    addresses),
544                                            com.liferay.portal.model.impl.EmailAddressModelImpl.toModels(
545                                                    emailAddresses),
546                                            com.liferay.portal.model.impl.PhoneModelImpl.toModels(
547                                                    phones),
548                                            com.liferay.portal.model.impl.WebsiteModelImpl.toModels(
549                                                    websites),
550                                            com.liferay.portlet.announcements.model.impl.AnnouncementsDeliveryModelImpl.toModels(
551                                                    announcementsDelivers), sendEmail, serviceContext);
552    
553                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
554                    }
555                    catch (Exception e) {
556                            _log.error(e, e);
557    
558                            throw new RemoteException(e.getMessage());
559                    }
560            }
561    
562            /**
563            * Deletes the user's portrait image.
564            *
565            * @param userId the primary key of the user
566            * @throws PortalException if a user with the primary key could not be
567            found, if the user's portrait could not be found, or if the
568            current user did not have permission to update the user
569            */
570            public static void deletePortrait(long userId) throws RemoteException {
571                    try {
572                            UserServiceUtil.deletePortrait(userId);
573                    }
574                    catch (Exception e) {
575                            _log.error(e, e);
576    
577                            throw new RemoteException(e.getMessage());
578                    }
579            }
580    
581            /**
582            * Removes the user from the role.
583            *
584            * @param roleId the primary key of the role
585            * @param userId the primary key of the user
586            * @throws PortalException if a role or user with the primary key could not
587            be found, or if the current user did not have permission to
588            assign role members
589            */
590            public static void deleteRoleUser(long roleId, long userId)
591                    throws RemoteException {
592                    try {
593                            UserServiceUtil.deleteRoleUser(roleId, userId);
594                    }
595                    catch (Exception e) {
596                            _log.error(e, e);
597    
598                            throw new RemoteException(e.getMessage());
599                    }
600            }
601    
602            /**
603            * Deletes the user.
604            *
605            * @param userId the primary key of the user
606            * @throws PortalException if a user with the primary key could not be found
607            or if the current user did not have permission to delete the user
608            */
609            public static void deleteUser(long userId) throws RemoteException {
610                    try {
611                            UserServiceUtil.deleteUser(userId);
612                    }
613                    catch (Exception e) {
614                            _log.error(e, e);
615    
616                            throw new RemoteException(e.getMessage());
617                    }
618            }
619    
620            public static com.liferay.portal.model.UserSoap[] getCompanyUsers(
621                    long companyId, int start, int end) throws RemoteException {
622                    try {
623                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getCompanyUsers(companyId,
624                                            start, end);
625    
626                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
627                    }
628                    catch (Exception e) {
629                            _log.error(e, e);
630    
631                            throw new RemoteException(e.getMessage());
632                    }
633            }
634    
635            public static int getCompanyUsersCount(long companyId)
636                    throws RemoteException {
637                    try {
638                            int returnValue = UserServiceUtil.getCompanyUsersCount(companyId);
639    
640                            return returnValue;
641                    }
642                    catch (Exception e) {
643                            _log.error(e, e);
644    
645                            throw new RemoteException(e.getMessage());
646                    }
647            }
648    
649            /**
650            * Returns the primary keys of all the users belonging to the group.
651            *
652            * @param groupId the primary key of the group
653            * @return the primary keys of the users belonging to the group
654            * @throws PortalException if the current user did not have permission to
655            view group assignments
656            */
657            public static long[] getGroupUserIds(long groupId)
658                    throws RemoteException {
659                    try {
660                            long[] returnValue = UserServiceUtil.getGroupUserIds(groupId);
661    
662                            return returnValue;
663                    }
664                    catch (Exception e) {
665                            _log.error(e, e);
666    
667                            throw new RemoteException(e.getMessage());
668                    }
669            }
670    
671            /**
672            * Returns all the users belonging to the group.
673            *
674            * @param groupId the primary key of the group
675            * @return the users belonging to the group
676            * @throws PortalException if the current user did not have permission to
677            view group assignments
678            */
679            public static com.liferay.portal.model.UserSoap[] getGroupUsers(
680                    long groupId) throws RemoteException {
681                    try {
682                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getGroupUsers(groupId);
683    
684                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
685                    }
686                    catch (Exception e) {
687                            _log.error(e, e);
688    
689                            throw new RemoteException(e.getMessage());
690                    }
691            }
692    
693            /**
694            * Returns the primary keys of all the users belonging to the organization.
695            *
696            * @param organizationId the primary key of the organization
697            * @return the primary keys of the users belonging to the organization
698            * @throws PortalException if the current user did not have permission to
699            view organization assignments
700            */
701            public static long[] getOrganizationUserIds(long organizationId)
702                    throws RemoteException {
703                    try {
704                            long[] returnValue = UserServiceUtil.getOrganizationUserIds(organizationId);
705    
706                            return returnValue;
707                    }
708                    catch (Exception e) {
709                            _log.error(e, e);
710    
711                            throw new RemoteException(e.getMessage());
712                    }
713            }
714    
715            /**
716            * Returns all the users belonging to the organization.
717            *
718            * @param organizationId the primary key of the organization
719            * @return users belonging to the organization
720            * @throws PortalException if the current user did not have permission to
721            view organization assignments
722            */
723            public static com.liferay.portal.model.UserSoap[] getOrganizationUsers(
724                    long organizationId) throws RemoteException {
725                    try {
726                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getOrganizationUsers(organizationId);
727    
728                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
729                    }
730                    catch (Exception e) {
731                            _log.error(e, e);
732    
733                            throw new RemoteException(e.getMessage());
734                    }
735            }
736    
737            /**
738            * Returns the primary keys of all the users belonging to the role.
739            *
740            * @param roleId the primary key of the role
741            * @return the primary keys of the users belonging to the role
742            * @throws PortalException if the current user did not have permission to
743            view role members
744            */
745            public static long[] getRoleUserIds(long roleId) throws RemoteException {
746                    try {
747                            long[] returnValue = UserServiceUtil.getRoleUserIds(roleId);
748    
749                            return returnValue;
750                    }
751                    catch (Exception e) {
752                            _log.error(e, e);
753    
754                            throw new RemoteException(e.getMessage());
755                    }
756            }
757    
758            /**
759            * Returns the user with the email address.
760            *
761            * @param companyId the primary key of the user's company
762            * @param emailAddress the user's email address
763            * @return the user with the email address
764            * @throws PortalException if a user with the email address could not be
765            found or if the current user did not have permission to view the
766            user
767            */
768            public static com.liferay.portal.model.UserSoap getUserByEmailAddress(
769                    long companyId, java.lang.String emailAddress)
770                    throws RemoteException {
771                    try {
772                            com.liferay.portal.model.User returnValue = UserServiceUtil.getUserByEmailAddress(companyId,
773                                            emailAddress);
774    
775                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
776                    }
777                    catch (Exception e) {
778                            _log.error(e, e);
779    
780                            throw new RemoteException(e.getMessage());
781                    }
782            }
783    
784            /**
785            * Returns the user with the primary key.
786            *
787            * @param userId the primary key of the user
788            * @return the user with the primary key
789            * @throws PortalException if a user with the primary key could not be found
790            or if the current user did not have permission to view the user
791            */
792            public static com.liferay.portal.model.UserSoap getUserById(long userId)
793                    throws RemoteException {
794                    try {
795                            com.liferay.portal.model.User returnValue = UserServiceUtil.getUserById(userId);
796    
797                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
798                    }
799                    catch (Exception e) {
800                            _log.error(e, e);
801    
802                            throw new RemoteException(e.getMessage());
803                    }
804            }
805    
806            /**
807            * Returns the user with the screen name.
808            *
809            * @param companyId the primary key of the user's company
810            * @param screenName the user's screen name
811            * @return the user with the screen name
812            * @throws PortalException if a user with the screen name could not be found
813            or if the current user did not have permission to view the user
814            */
815            public static com.liferay.portal.model.UserSoap getUserByScreenName(
816                    long companyId, java.lang.String screenName) throws RemoteException {
817                    try {
818                            com.liferay.portal.model.User returnValue = UserServiceUtil.getUserByScreenName(companyId,
819                                            screenName);
820    
821                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
822                    }
823                    catch (Exception e) {
824                            _log.error(e, e);
825    
826                            throw new RemoteException(e.getMessage());
827                    }
828            }
829    
830            public static com.liferay.portal.model.UserSoap[] getUserGroupUsers(
831                    long userGroupId) throws RemoteException {
832                    try {
833                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getUserGroupUsers(userGroupId);
834    
835                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
836                    }
837                    catch (Exception e) {
838                            _log.error(e, e);
839    
840                            throw new RemoteException(e.getMessage());
841                    }
842            }
843    
844            /**
845            * Returns the primary key of the user with the email address.
846            *
847            * @param companyId the primary key of the user's company
848            * @param emailAddress the user's email address
849            * @return the primary key of the user with the email address
850            * @throws PortalException if a user with the email address could not be
851            found
852            */
853            public static long getUserIdByEmailAddress(long companyId,
854                    java.lang.String emailAddress) throws RemoteException {
855                    try {
856                            long returnValue = UserServiceUtil.getUserIdByEmailAddress(companyId,
857                                            emailAddress);
858    
859                            return returnValue;
860                    }
861                    catch (Exception e) {
862                            _log.error(e, e);
863    
864                            throw new RemoteException(e.getMessage());
865                    }
866            }
867    
868            /**
869            * Returns the primary key of the user with the screen name.
870            *
871            * @param companyId the primary key of the user's company
872            * @param screenName the user's screen name
873            * @return the primary key of the user with the screen name
874            * @throws PortalException if a user with the screen name could not be found
875            */
876            public static long getUserIdByScreenName(long companyId,
877                    java.lang.String screenName) throws RemoteException {
878                    try {
879                            long returnValue = UserServiceUtil.getUserIdByScreenName(companyId,
880                                            screenName);
881    
882                            return returnValue;
883                    }
884                    catch (Exception e) {
885                            _log.error(e, e);
886    
887                            throw new RemoteException(e.getMessage());
888                    }
889            }
890    
891            /**
892            * Returns <code>true</code> if the user is a member of the group.
893            *
894            * @param groupId the primary key of the group
895            * @param userId the primary key of the user
896            * @return <code>true</code> if the user is a member of the group;
897            <code>false</code> otherwise
898            * @throws PortalException if the current user did not have permission to
899            view the user or group members
900            */
901            public static boolean hasGroupUser(long groupId, long userId)
902                    throws RemoteException {
903                    try {
904                            boolean returnValue = UserServiceUtil.hasGroupUser(groupId, userId);
905    
906                            return returnValue;
907                    }
908                    catch (Exception e) {
909                            _log.error(e, e);
910    
911                            throw new RemoteException(e.getMessage());
912                    }
913            }
914    
915            /**
916            * Returns <code>true</code> if the user is a member of the role.
917            *
918            * @param roleId the primary key of the role
919            * @param userId the primary key of the user
920            * @return <code>true</code> if the user is a member of the role;
921            <code>false</code> otherwise
922            * @throws PortalException if the current user did not have permission to
923            view the user or role members
924            */
925            public static boolean hasRoleUser(long roleId, long userId)
926                    throws RemoteException {
927                    try {
928                            boolean returnValue = UserServiceUtil.hasRoleUser(roleId, userId);
929    
930                            return returnValue;
931                    }
932                    catch (Exception e) {
933                            _log.error(e, e);
934    
935                            throw new RemoteException(e.getMessage());
936                    }
937            }
938    
939            /**
940            * Returns <code>true</code> if the user has the role with the name,
941            * optionally through inheritance.
942            *
943            * @param companyId the primary key of the role's company
944            * @param name the name of the role (must be a regular role, not an
945            organization, site or provider role)
946            * @param userId the primary key of the user
947            * @param inherited whether to include roles inherited from organizations,
948            sites, etc.
949            * @return <code>true</code> if the user has the role; <code>false</code>
950            otherwise
951            * @throws PortalException if a role with the name could not be found
952            */
953            public static boolean hasRoleUser(long companyId, java.lang.String name,
954                    long userId, boolean inherited) throws RemoteException {
955                    try {
956                            boolean returnValue = UserServiceUtil.hasRoleUser(companyId, name,
957                                            userId, inherited);
958    
959                            return returnValue;
960                    }
961                    catch (Exception e) {
962                            _log.error(e, e);
963    
964                            throw new RemoteException(e.getMessage());
965                    }
966            }
967    
968            public static boolean sendPasswordByEmailAddress(long companyId,
969                    java.lang.String emailAddress) throws RemoteException {
970                    try {
971                            boolean returnValue = UserServiceUtil.sendPasswordByEmailAddress(companyId,
972                                            emailAddress);
973    
974                            return returnValue;
975                    }
976                    catch (Exception e) {
977                            _log.error(e, e);
978    
979                            throw new RemoteException(e.getMessage());
980                    }
981            }
982    
983            public static boolean sendPasswordByScreenName(long companyId,
984                    java.lang.String screenName) throws RemoteException {
985                    try {
986                            boolean returnValue = UserServiceUtil.sendPasswordByScreenName(companyId,
987                                            screenName);
988    
989                            return returnValue;
990                    }
991                    catch (Exception e) {
992                            _log.error(e, e);
993    
994                            throw new RemoteException(e.getMessage());
995                    }
996            }
997    
998            public static boolean sendPasswordByUserId(long userId)
999                    throws RemoteException {
1000                    try {
1001                            boolean returnValue = UserServiceUtil.sendPasswordByUserId(userId);
1002    
1003                            return returnValue;
1004                    }
1005                    catch (Exception e) {
1006                            _log.error(e, e);
1007    
1008                            throw new RemoteException(e.getMessage());
1009                    }
1010            }
1011    
1012            /**
1013            * Sets the users in the role, removing and adding users to the role as
1014            * necessary.
1015            *
1016            * @param roleId the primary key of the role
1017            * @param userIds the primary keys of the users
1018            * @throws PortalException if the current user did not have permission to
1019            assign role members or if the operation was not allowed by the
1020            membership policy
1021            */
1022            public static void setRoleUsers(long roleId, long[] userIds)
1023                    throws RemoteException {
1024                    try {
1025                            UserServiceUtil.setRoleUsers(roleId, userIds);
1026                    }
1027                    catch (Exception e) {
1028                            _log.error(e, e);
1029    
1030                            throw new RemoteException(e.getMessage());
1031                    }
1032            }
1033    
1034            /**
1035            * Sets the users in the user group, removing and adding users to the user
1036            * group as necessary.
1037            *
1038            * @param userGroupId the primary key of the user group
1039            * @param userIds the primary keys of the users
1040            * @throws PortalException if the current user did not have permission to
1041            assign group members
1042            */
1043            public static void setUserGroupUsers(long userGroupId, long[] userIds)
1044                    throws RemoteException {
1045                    try {
1046                            UserServiceUtil.setUserGroupUsers(userGroupId, userIds);
1047                    }
1048                    catch (Exception e) {
1049                            _log.error(e, e);
1050    
1051                            throw new RemoteException(e.getMessage());
1052                    }
1053            }
1054    
1055            /**
1056            * Removes the users from the teams of a group.
1057            *
1058            * @param groupId the primary key of the group
1059            * @param userIds the primary keys of the users
1060            * @throws PortalException if the current user did not have permission to
1061            modify user group assignments
1062            */
1063            public static void unsetGroupTeamsUsers(long groupId, long[] userIds)
1064                    throws RemoteException {
1065                    try {
1066                            UserServiceUtil.unsetGroupTeamsUsers(groupId, userIds);
1067                    }
1068                    catch (Exception e) {
1069                            _log.error(e, e);
1070    
1071                            throw new RemoteException(e.getMessage());
1072                    }
1073            }
1074    
1075            /**
1076            * Removes the users from the group.
1077            *
1078            * @param groupId the primary key of the group
1079            * @param userIds the primary keys of the users
1080            * @param serviceContext the service context to be applied (optionally
1081            <code>null</code>)
1082            * @throws PortalException if the current user did not have permission to
1083            modify group assignments or if the operation was not allowed by
1084            the membership policy
1085            */
1086            public static void unsetGroupUsers(long groupId, long[] userIds,
1087                    com.liferay.portal.service.ServiceContext serviceContext)
1088                    throws RemoteException {
1089                    try {
1090                            UserServiceUtil.unsetGroupUsers(groupId, userIds, serviceContext);
1091                    }
1092                    catch (Exception e) {
1093                            _log.error(e, e);
1094    
1095                            throw new RemoteException(e.getMessage());
1096                    }
1097            }
1098    
1099            /**
1100            * Removes the users from the organization.
1101            *
1102            * @param organizationId the primary key of the organization
1103            * @param userIds the primary keys of the users
1104            * @throws PortalException if the current user did not have permission to
1105            modify organization assignments or if the operation was not
1106            allowed by the membership policy
1107            */
1108            public static void unsetOrganizationUsers(long organizationId,
1109                    long[] userIds) throws RemoteException {
1110                    try {
1111                            UserServiceUtil.unsetOrganizationUsers(organizationId, userIds);
1112                    }
1113                    catch (Exception e) {
1114                            _log.error(e, e);
1115    
1116                            throw new RemoteException(e.getMessage());
1117                    }
1118            }
1119    
1120            /**
1121            * Removes the users from the password policy.
1122            *
1123            * @param passwordPolicyId the primary key of the password policy
1124            * @param userIds the primary keys of the users
1125            * @throws PortalException if the current user did not have permission to
1126            modify policy assignments
1127            */
1128            public static void unsetPasswordPolicyUsers(long passwordPolicyId,
1129                    long[] userIds) throws RemoteException {
1130                    try {
1131                            UserServiceUtil.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
1132                    }
1133                    catch (Exception e) {
1134                            _log.error(e, e);
1135    
1136                            throw new RemoteException(e.getMessage());
1137                    }
1138            }
1139    
1140            /**
1141            * Removes the users from the role.
1142            *
1143            * @param roleId the primary key of the role
1144            * @param userIds the primary keys of the users
1145            * @throws PortalException if the current user did not have permission to
1146            modify role assignments or if the operation was not allowed by
1147            the membership policy
1148            */
1149            public static void unsetRoleUsers(long roleId, long[] userIds)
1150                    throws RemoteException {
1151                    try {
1152                            UserServiceUtil.unsetRoleUsers(roleId, userIds);
1153                    }
1154                    catch (Exception e) {
1155                            _log.error(e, e);
1156    
1157                            throw new RemoteException(e.getMessage());
1158                    }
1159            }
1160    
1161            /**
1162            * Removes the users from the team.
1163            *
1164            * @param teamId the primary key of the team
1165            * @param userIds the primary keys of the users
1166            * @throws PortalException if the current user did not have permission to
1167            modify team assignments
1168            */
1169            public static void unsetTeamUsers(long teamId, long[] userIds)
1170                    throws RemoteException {
1171                    try {
1172                            UserServiceUtil.unsetTeamUsers(teamId, userIds);
1173                    }
1174                    catch (Exception e) {
1175                            _log.error(e, e);
1176    
1177                            throw new RemoteException(e.getMessage());
1178                    }
1179            }
1180    
1181            /**
1182            * Removes the users from the user group.
1183            *
1184            * @param userGroupId the primary key of the user group
1185            * @param userIds the primary keys of the users
1186            * @throws PortalException if the current user did not have permission to
1187            modify user group assignments or if the operation was not allowed
1188            by the membership policy
1189            */
1190            public static void unsetUserGroupUsers(long userGroupId, long[] userIds)
1191                    throws RemoteException {
1192                    try {
1193                            UserServiceUtil.unsetUserGroupUsers(userGroupId, userIds);
1194                    }
1195                    catch (Exception e) {
1196                            _log.error(e, e);
1197    
1198                            throw new RemoteException(e.getMessage());
1199                    }
1200            }
1201    
1202            /**
1203            * Updates the user's response to the terms of use agreement.
1204            *
1205            * @param userId the primary key of the user
1206            * @param agreedToTermsOfUse whether the user has agree to the terms of use
1207            * @return the user
1208            * @throws PortalException if the current user did not have permission to
1209            update the user's agreement to terms-of-use
1210            */
1211            public static com.liferay.portal.model.UserSoap updateAgreedToTermsOfUse(
1212                    long userId, boolean agreedToTermsOfUse) throws RemoteException {
1213                    try {
1214                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateAgreedToTermsOfUse(userId,
1215                                            agreedToTermsOfUse);
1216    
1217                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1218                    }
1219                    catch (Exception e) {
1220                            _log.error(e, e);
1221    
1222                            throw new RemoteException(e.getMessage());
1223                    }
1224            }
1225    
1226            /**
1227            * Updates the user's email address.
1228            *
1229            * @param userId the primary key of the user
1230            * @param password the user's password
1231            * @param emailAddress1 the user's new email address
1232            * @param emailAddress2 the user's new email address confirmation
1233            * @param serviceContext the service context to be applied. Must set the
1234            portal URL, main path, primary key of the layout, remote address,
1235            remote host, and agent for the user.
1236            * @return the user
1237            * @throws PortalException if a user with the primary key could not be found
1238            or if the current user did not have permission to update the user
1239            */
1240            public static com.liferay.portal.model.UserSoap updateEmailAddress(
1241                    long userId, java.lang.String password, java.lang.String emailAddress1,
1242                    java.lang.String emailAddress2,
1243                    com.liferay.portal.service.ServiceContext serviceContext)
1244                    throws RemoteException {
1245                    try {
1246                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateEmailAddress(userId,
1247                                            password, emailAddress1, emailAddress2, serviceContext);
1248    
1249                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1250                    }
1251                    catch (Exception e) {
1252                            _log.error(e, e);
1253    
1254                            throw new RemoteException(e.getMessage());
1255                    }
1256            }
1257    
1258            /**
1259            * Updates a user account that was automatically created when a guest user
1260            * participated in an action (e.g. posting a comment) and only provided his
1261            * name and email address.
1262            *
1263            * @param companyId the primary key of the user's company
1264            * @param autoPassword whether a password should be automatically generated
1265            for the user
1266            * @param password1 the user's password
1267            * @param password2 the user's password confirmation
1268            * @param autoScreenName whether a screen name should be automatically
1269            generated for the user
1270            * @param screenName the user's screen name
1271            * @param emailAddress the user's email address
1272            * @param facebookId the user's facebook ID
1273            * @param openId the user's OpenID
1274            * @param locale the user's locale
1275            * @param firstName the user's first name
1276            * @param middleName the user's middle name
1277            * @param lastName the user's last name
1278            * @param prefixId the user's name prefix ID
1279            * @param suffixId the user's name suffix ID
1280            * @param male whether the user is male
1281            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
1282            January)
1283            * @param birthdayDay the user's birthday day
1284            * @param birthdayYear the user's birthday year
1285            * @param jobTitle the user's job title
1286            * @param updateUserInformation whether to update the user's information
1287            * @param sendEmail whether to send the user an email notification about
1288            their new account
1289            * @param serviceContext the service context to be applied (optionally
1290            <code>null</code>). Can set the expando bridge attributes for the
1291            user.
1292            * @return the user
1293            * @throws PortalException if the user's information was invalid or if the
1294            email address was reserved
1295            */
1296            public static com.liferay.portal.model.UserSoap updateIncompleteUser(
1297                    long companyId, boolean autoPassword, java.lang.String password1,
1298                    java.lang.String password2, boolean autoScreenName,
1299                    java.lang.String screenName, java.lang.String emailAddress,
1300                    long facebookId, java.lang.String openId, String locale,
1301                    java.lang.String firstName, java.lang.String middleName,
1302                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
1303                    int birthdayMonth, int birthdayDay, int birthdayYear,
1304                    java.lang.String jobTitle, boolean updateUserInformation,
1305                    boolean sendEmail,
1306                    com.liferay.portal.service.ServiceContext serviceContext)
1307                    throws RemoteException {
1308                    try {
1309                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateIncompleteUser(companyId,
1310                                            autoPassword, password1, password2, autoScreenName,
1311                                            screenName, emailAddress, facebookId, openId,
1312                                            LocaleUtil.fromLanguageId(locale), firstName, middleName,
1313                                            lastName, prefixId, suffixId, male, birthdayMonth,
1314                                            birthdayDay, birthdayYear, jobTitle, updateUserInformation,
1315                                            sendEmail, serviceContext);
1316    
1317                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1318                    }
1319                    catch (Exception e) {
1320                            _log.error(e, e);
1321    
1322                            throw new RemoteException(e.getMessage());
1323                    }
1324            }
1325    
1326            /**
1327            * Updates whether the user is locked out from logging in.
1328            *
1329            * @param userId the primary key of the user
1330            * @param lockout whether the user is locked out
1331            * @return the user
1332            * @throws PortalException if the user did not have permission to lock out
1333            the user
1334            */
1335            public static com.liferay.portal.model.UserSoap updateLockoutById(
1336                    long userId, boolean lockout) throws RemoteException {
1337                    try {
1338                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateLockoutById(userId,
1339                                            lockout);
1340    
1341                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1342                    }
1343                    catch (Exception e) {
1344                            _log.error(e, e);
1345    
1346                            throw new RemoteException(e.getMessage());
1347                    }
1348            }
1349    
1350            /**
1351            * Updates the user's OpenID.
1352            *
1353            * @param userId the primary key of the user
1354            * @param openId the new OpenID
1355            * @return the user
1356            * @throws PortalException if a user with the primary key could not be found
1357            or if the current user did not have permission to update the user
1358            */
1359            public static com.liferay.portal.model.UserSoap updateOpenId(long userId,
1360                    java.lang.String openId) throws RemoteException {
1361                    try {
1362                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateOpenId(userId,
1363                                            openId);
1364    
1365                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1366                    }
1367                    catch (Exception e) {
1368                            _log.error(e, e);
1369    
1370                            throw new RemoteException(e.getMessage());
1371                    }
1372            }
1373    
1374            /**
1375            * Sets the organizations that the user is in, removing and adding
1376            * organizations as necessary.
1377            *
1378            * @param userId the primary key of the user
1379            * @param organizationIds the primary keys of the organizations
1380            * @param serviceContext the service context to be applied. Must set
1381            whether user indexing is enabled.
1382            * @throws PortalException if a user with the primary key could not be found
1383            or if the current user did not have permission to update the user
1384            */
1385            public static void updateOrganizations(long userId, long[] organizationIds,
1386                    com.liferay.portal.service.ServiceContext serviceContext)
1387                    throws RemoteException {
1388                    try {
1389                            UserServiceUtil.updateOrganizations(userId, organizationIds,
1390                                    serviceContext);
1391                    }
1392                    catch (Exception e) {
1393                            _log.error(e, e);
1394    
1395                            throw new RemoteException(e.getMessage());
1396                    }
1397            }
1398    
1399            /**
1400            * Updates the user's password without tracking or validation of the change.
1401            *
1402            * @param userId the primary key of the user
1403            * @param password1 the user's new password
1404            * @param password2 the user's new password confirmation
1405            * @param passwordReset whether the user should be asked to reset their
1406            password the next time they log in
1407            * @return the user
1408            * @throws PortalException if a user with the primary key could not be found
1409            or if the current user did not have permission to update the user
1410            */
1411            public static com.liferay.portal.model.UserSoap updatePassword(
1412                    long userId, java.lang.String password1, java.lang.String password2,
1413                    boolean passwordReset) throws RemoteException {
1414                    try {
1415                            com.liferay.portal.model.User returnValue = UserServiceUtil.updatePassword(userId,
1416                                            password1, password2, passwordReset);
1417    
1418                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1419                    }
1420                    catch (Exception e) {
1421                            _log.error(e, e);
1422    
1423                            throw new RemoteException(e.getMessage());
1424                    }
1425            }
1426    
1427            /**
1428            * Updates the user's portrait image.
1429            *
1430            * @param userId the primary key of the user
1431            * @param bytes the new portrait image data
1432            * @return the user
1433            * @throws PortalException if a user with the primary key could not be
1434            found, if the new portrait was invalid, or if the current user
1435            did not have permission to update the user
1436            */
1437            public static com.liferay.portal.model.UserSoap updatePortrait(
1438                    long userId, byte[] bytes) throws RemoteException {
1439                    try {
1440                            com.liferay.portal.model.User returnValue = UserServiceUtil.updatePortrait(userId,
1441                                            bytes);
1442    
1443                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1444                    }
1445                    catch (Exception e) {
1446                            _log.error(e, e);
1447    
1448                            throw new RemoteException(e.getMessage());
1449                    }
1450            }
1451    
1452            /**
1453            * Updates the user's password reset question and answer.
1454            *
1455            * @param userId the primary key of the user
1456            * @param question the user's new password reset question
1457            * @param answer the user's new password reset answer
1458            * @return the user
1459            * @throws PortalException if a user with the primary key could not be
1460            found, if the new question or answer were invalid, or if the
1461            current user did not have permission to update the user
1462            */
1463            public static com.liferay.portal.model.UserSoap updateReminderQuery(
1464                    long userId, java.lang.String question, java.lang.String answer)
1465                    throws RemoteException {
1466                    try {
1467                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateReminderQuery(userId,
1468                                            question, answer);
1469    
1470                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1471                    }
1472                    catch (Exception e) {
1473                            _log.error(e, e);
1474    
1475                            throw new RemoteException(e.getMessage());
1476                    }
1477            }
1478    
1479            /**
1480            * Updates the user's screen name.
1481            *
1482            * @param userId the primary key of the user
1483            * @param screenName the user's new screen name
1484            * @return the user
1485            * @throws PortalException if a user with the primary key could not be
1486            found, if the new screen name was invalid, or if the current user
1487            did not have permission to update the user
1488            */
1489            public static com.liferay.portal.model.UserSoap updateScreenName(
1490                    long userId, java.lang.String screenName) throws RemoteException {
1491                    try {
1492                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateScreenName(userId,
1493                                            screenName);
1494    
1495                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1496                    }
1497                    catch (Exception e) {
1498                            _log.error(e, e);
1499    
1500                            throw new RemoteException(e.getMessage());
1501                    }
1502            }
1503    
1504            /**
1505            * Updates the user's workflow status.
1506            *
1507            * @param userId the primary key of the user
1508            * @param status the user's new workflow status
1509            * @return the user
1510            * @throws PortalException if a user with the primary key could not be
1511            found, if the current user was updating her own status to
1512            anything but {@link
1513            com.liferay.portal.kernel.workflow.WorkflowConstants#STATUS_APPROVED},
1514            or if the current user did not have permission to update the
1515            user's workflow status.
1516            * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int,
1517            ServiceContext)}
1518            */
1519            @Deprecated
1520            public static com.liferay.portal.model.UserSoap updateStatus(long userId,
1521                    int status) throws RemoteException {
1522                    try {
1523                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateStatus(userId,
1524                                            status);
1525    
1526                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1527                    }
1528                    catch (Exception e) {
1529                            _log.error(e, e);
1530    
1531                            throw new RemoteException(e.getMessage());
1532                    }
1533            }
1534    
1535            /**
1536            * Updates the user's workflow status.
1537            *
1538            * @param userId the primary key of the user
1539            * @param status the user's new workflow status
1540            * @param serviceContext the service context to be applied. You can specify
1541            an unencrypted custom password (used by an LDAP listener) for the
1542            user via attribute <code>passwordUnencrypted</code>.
1543            * @return the user
1544            * @throws PortalException if a user with the primary key could not be
1545            found, if the current user was updating her own status to
1546            anything but {@link
1547            com.liferay.portal.kernel.workflow.WorkflowConstants#STATUS_APPROVED},
1548            or if the current user did not have permission to update the
1549            user's workflow status.
1550            */
1551            public static com.liferay.portal.model.UserSoap updateStatus(long userId,
1552                    int status, com.liferay.portal.service.ServiceContext serviceContext)
1553                    throws RemoteException {
1554                    try {
1555                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateStatus(userId,
1556                                            status, serviceContext);
1557    
1558                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1559                    }
1560                    catch (Exception e) {
1561                            _log.error(e, e);
1562    
1563                            throw new RemoteException(e.getMessage());
1564                    }
1565            }
1566    
1567            /**
1568            * Updates the user with additional parameters.
1569            *
1570            * @param userId the primary key of the user
1571            * @param oldPassword the user's old password
1572            * @param newPassword1 the user's new password (optionally
1573            <code>null</code>)
1574            * @param newPassword2 the user's new password confirmation (optionally
1575            <code>null</code>)
1576            * @param passwordReset whether the user should be asked to reset their
1577            password the next time they login
1578            * @param reminderQueryQuestion the user's new password reset question
1579            * @param reminderQueryAnswer the user's new password reset answer
1580            * @param screenName the user's new screen name
1581            * @param emailAddress the user's new email address
1582            * @param facebookId the user's new Facebook ID
1583            * @param openId the user's new OpenID
1584            * @param portrait whether to update the user's portrait image
1585            * @param portraitBytes the new portrait image data
1586            * @param languageId the user's new language ID
1587            * @param timeZoneId the user's new time zone ID
1588            * @param greeting the user's new greeting
1589            * @param comments the user's new comments
1590            * @param firstName the user's new first name
1591            * @param middleName the user's new middle name
1592            * @param lastName the user's new last name
1593            * @param prefixId the user's new name prefix ID
1594            * @param suffixId the user's new name suffix ID
1595            * @param male whether user is male
1596            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
1597            for January)
1598            * @param birthdayDay the user's new birthday day
1599            * @param birthdayYear the user's birthday year
1600            * @param smsSn the user's new SMS screen name
1601            * @param aimSn the user's new AIM screen name
1602            * @param facebookSn the user's new Facebook screen name
1603            * @param icqSn the user's new ICQ screen name
1604            * @param jabberSn the user's new Jabber screen name
1605            * @param msnSn the user's new MSN screen name
1606            * @param mySpaceSn the user's new MySpace screen name
1607            * @param skypeSn the user's new Skype screen name
1608            * @param twitterSn the user's new Twitter screen name
1609            * @param ymSn the user's new Yahoo! Messenger screen name
1610            * @param jobTitle the user's new job title
1611            * @param groupIds the primary keys of the user's groups
1612            * @param organizationIds the primary keys of the user's organizations
1613            * @param roleIds the primary keys of the user's roles
1614            * @param userGroupRoles the user user's group roles
1615            * @param userGroupIds the primary keys of the user's user groups
1616            * @param addresses the user's addresses
1617            * @param emailAddresses the user's email addresses
1618            * @param phones the user's phone numbers
1619            * @param websites the user's websites
1620            * @param announcementsDelivers the announcements deliveries
1621            * @param serviceContext the service context to be applied (optionally
1622            <code>null</code>). Can set the UUID (with the <code>uuid</code>
1623            attribute), asset category IDs, asset tag names, and expando
1624            bridge attributes for the user.
1625            * @return the user
1626            * @throws PortalException if a user with the primary key could not be
1627            found, if the new information was invalid, if the current user
1628            did not have permission to update the user, or if the operation
1629            was not allowed by the membership policy
1630            */
1631            public static com.liferay.portal.model.UserSoap updateUser(long userId,
1632                    java.lang.String oldPassword, java.lang.String newPassword1,
1633                    java.lang.String newPassword2, boolean passwordReset,
1634                    java.lang.String reminderQueryQuestion,
1635                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
1636                    java.lang.String emailAddress, long facebookId,
1637                    java.lang.String openId, boolean portrait, byte[] portraitBytes,
1638                    java.lang.String languageId, java.lang.String timeZoneId,
1639                    java.lang.String greeting, java.lang.String comments,
1640                    java.lang.String firstName, java.lang.String middleName,
1641                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
1642                    int birthdayMonth, int birthdayDay, int birthdayYear,
1643                    java.lang.String smsSn, java.lang.String aimSn,
1644                    java.lang.String facebookSn, java.lang.String icqSn,
1645                    java.lang.String jabberSn, java.lang.String msnSn,
1646                    java.lang.String mySpaceSn, java.lang.String skypeSn,
1647                    java.lang.String twitterSn, java.lang.String ymSn,
1648                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
1649                    long[] roleIds,
1650                    com.liferay.portal.model.UserGroupRoleSoap[] userGroupRoles,
1651                    long[] userGroupIds, com.liferay.portal.model.AddressSoap[] addresses,
1652                    com.liferay.portal.model.EmailAddressSoap[] emailAddresses,
1653                    com.liferay.portal.model.PhoneSoap[] phones,
1654                    com.liferay.portal.model.WebsiteSoap[] websites,
1655                    com.liferay.portlet.announcements.model.AnnouncementsDeliverySoap[] announcementsDelivers,
1656                    com.liferay.portal.service.ServiceContext serviceContext)
1657                    throws RemoteException {
1658                    try {
1659                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateUser(userId,
1660                                            oldPassword, newPassword1, newPassword2, passwordReset,
1661                                            reminderQueryQuestion, reminderQueryAnswer, screenName,
1662                                            emailAddress, facebookId, openId, portrait, portraitBytes,
1663                                            languageId, timeZoneId, greeting, comments, firstName,
1664                                            middleName, lastName, prefixId, suffixId, male,
1665                                            birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn,
1666                                            facebookSn, icqSn, jabberSn, msnSn, mySpaceSn, skypeSn,
1667                                            twitterSn, ymSn, jobTitle, groupIds, organizationIds,
1668                                            roleIds,
1669                                            com.liferay.portal.model.impl.UserGroupRoleModelImpl.toModels(
1670                                                    userGroupRoles), userGroupIds,
1671                                            com.liferay.portal.model.impl.AddressModelImpl.toModels(
1672                                                    addresses),
1673                                            com.liferay.portal.model.impl.EmailAddressModelImpl.toModels(
1674                                                    emailAddresses),
1675                                            com.liferay.portal.model.impl.PhoneModelImpl.toModels(
1676                                                    phones),
1677                                            com.liferay.portal.model.impl.WebsiteModelImpl.toModels(
1678                                                    websites),
1679                                            com.liferay.portlet.announcements.model.impl.AnnouncementsDeliveryModelImpl.toModels(
1680                                                    announcementsDelivers), serviceContext);
1681    
1682                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1683                    }
1684                    catch (Exception e) {
1685                            _log.error(e, e);
1686    
1687                            throw new RemoteException(e.getMessage());
1688                    }
1689            }
1690    
1691            /**
1692            * Updates the user with additional parameters.
1693            *
1694            * @param userId the primary key of the user
1695            * @param oldPassword the user's old password
1696            * @param newPassword1 the user's new password (optionally
1697            <code>null</code>)
1698            * @param newPassword2 the user's new password confirmation (optionally
1699            <code>null</code>)
1700            * @param passwordReset whether the user should be asked to reset their
1701            password the next time they login
1702            * @param reminderQueryQuestion the user's new password reset question
1703            * @param reminderQueryAnswer the user's new password reset answer
1704            * @param screenName the user's new screen name
1705            * @param emailAddress the user's new email address
1706            * @param facebookId the user's new Facebook ID
1707            * @param openId the user's new OpenID
1708            * @param languageId the user's new language ID
1709            * @param timeZoneId the user's new time zone ID
1710            * @param greeting the user's new greeting
1711            * @param comments the user's new comments
1712            * @param firstName the user's new first name
1713            * @param middleName the user's new middle name
1714            * @param lastName the user's new last name
1715            * @param prefixId the user's new name prefix ID
1716            * @param suffixId the user's new name suffix ID
1717            * @param male whether user is male
1718            * @param birthdayMonth the user's new birthday month (0-based, meaning
1719            0 for January)
1720            * @param birthdayDay the user's new birthday day
1721            * @param birthdayYear the user's birthday year
1722            * @param smsSn the user's new SMS screen name
1723            * @param aimSn the user's new AIM screen name
1724            * @param facebookSn the user's new Facebook screen name
1725            * @param icqSn the user's new ICQ screen name
1726            * @param jabberSn the user's new Jabber screen name
1727            * @param msnSn the user's new MSN screen name
1728            * @param mySpaceSn the user's new MySpace screen name
1729            * @param skypeSn the user's new Skype screen name
1730            * @param twitterSn the user's new Twitter screen name
1731            * @param ymSn the user's new Yahoo! Messenger screen name
1732            * @param jobTitle the user's new job title
1733            * @param groupIds the primary keys of the user's groups
1734            * @param organizationIds the primary keys of the user's organizations
1735            * @param roleIds the primary keys of the user's roles
1736            * @param userGroupRoles the user user's group roles
1737            * @param userGroupIds the primary keys of the user's user groups
1738            * @param addresses the user's addresses
1739            * @param emailAddresses the user's email addresses
1740            * @param phones the user's phone numbers
1741            * @param websites the user's websites
1742            * @param announcementsDelivers the announcements deliveries
1743            * @param serviceContext the service context to be applied (optionally
1744            <code>null</code>). Can set the UUID (with the
1745            <code>uuid</code> attribute), asset category IDs, asset tag
1746            names, and expando bridge attributes for the user.
1747            * @return the user
1748            * @throws PortalException if a user with the primary key could not be
1749            found, if the new information was invalid, if the current
1750            user did not have permission to update the user, or if the
1751            operation was not allowed by the membership policy
1752            * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String,
1753            String, String, boolean, String, String, String, String,
1754            long, String, String, String, String, String, String, String,
1755            String, int, int, boolean, int, int, int, String, String,
1756            String, String, String, String, String, String, String,
1757            String, String, long[], long[], long[], java.util.List,
1758            long[], java.util.List, java.util.List, java.util.List,
1759            java.util.List, java.util.List, boolean, byte[],
1760            com.liferay.portal.service.ServiceContext)}
1761            */
1762            @Deprecated
1763            public static com.liferay.portal.model.UserSoap updateUser(long userId,
1764                    java.lang.String oldPassword, java.lang.String newPassword1,
1765                    java.lang.String newPassword2, boolean passwordReset,
1766                    java.lang.String reminderQueryQuestion,
1767                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
1768                    java.lang.String emailAddress, long facebookId,
1769                    java.lang.String openId, java.lang.String languageId,
1770                    java.lang.String timeZoneId, java.lang.String greeting,
1771                    java.lang.String comments, java.lang.String firstName,
1772                    java.lang.String middleName, java.lang.String lastName, int prefixId,
1773                    int suffixId, boolean male, int birthdayMonth, int birthdayDay,
1774                    int birthdayYear, java.lang.String smsSn, java.lang.String aimSn,
1775                    java.lang.String facebookSn, java.lang.String icqSn,
1776                    java.lang.String jabberSn, java.lang.String msnSn,
1777                    java.lang.String mySpaceSn, java.lang.String skypeSn,
1778                    java.lang.String twitterSn, java.lang.String ymSn,
1779                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
1780                    long[] roleIds,
1781                    com.liferay.portal.model.UserGroupRoleSoap[] userGroupRoles,
1782                    long[] userGroupIds, com.liferay.portal.model.AddressSoap[] addresses,
1783                    com.liferay.portal.model.EmailAddressSoap[] emailAddresses,
1784                    com.liferay.portal.model.PhoneSoap[] phones,
1785                    com.liferay.portal.model.WebsiteSoap[] websites,
1786                    com.liferay.portlet.announcements.model.AnnouncementsDeliverySoap[] announcementsDelivers,
1787                    com.liferay.portal.service.ServiceContext serviceContext)
1788                    throws RemoteException {
1789                    try {
1790                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateUser(userId,
1791                                            oldPassword, newPassword1, newPassword2, passwordReset,
1792                                            reminderQueryQuestion, reminderQueryAnswer, screenName,
1793                                            emailAddress, facebookId, openId, languageId, timeZoneId,
1794                                            greeting, comments, firstName, middleName, lastName,
1795                                            prefixId, suffixId, male, birthdayMonth, birthdayDay,
1796                                            birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn,
1797                                            msnSn, mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle,
1798                                            groupIds, organizationIds, roleIds,
1799                                            com.liferay.portal.model.impl.UserGroupRoleModelImpl.toModels(
1800                                                    userGroupRoles), userGroupIds,
1801                                            com.liferay.portal.model.impl.AddressModelImpl.toModels(
1802                                                    addresses),
1803                                            com.liferay.portal.model.impl.EmailAddressModelImpl.toModels(
1804                                                    emailAddresses),
1805                                            com.liferay.portal.model.impl.PhoneModelImpl.toModels(
1806                                                    phones),
1807                                            com.liferay.portal.model.impl.WebsiteModelImpl.toModels(
1808                                                    websites),
1809                                            com.liferay.portlet.announcements.model.impl.AnnouncementsDeliveryModelImpl.toModels(
1810                                                    announcementsDelivers), serviceContext);
1811    
1812                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1813                    }
1814                    catch (Exception e) {
1815                            _log.error(e, e);
1816    
1817                            throw new RemoteException(e.getMessage());
1818                    }
1819            }
1820    
1821            /**
1822            * Updates the user.
1823            *
1824            * @param userId the primary key of the user
1825            * @param oldPassword the user's old password
1826            * @param newPassword1 the user's new password (optionally
1827            <code>null</code>)
1828            * @param newPassword2 the user's new password confirmation (optionally
1829            <code>null</code>)
1830            * @param passwordReset whether the user should be asked to reset their
1831            password the next time they login
1832            * @param reminderQueryQuestion the user's new password reset question
1833            * @param reminderQueryAnswer the user's new password reset answer
1834            * @param screenName the user's new screen name
1835            * @param emailAddress the user's new email address
1836            * @param facebookId the user's new Facebook ID
1837            * @param openId the user's new OpenID
1838            * @param languageId the user's new language ID
1839            * @param timeZoneId the user's new time zone ID
1840            * @param greeting the user's new greeting
1841            * @param comments the user's new comments
1842            * @param firstName the user's new first name
1843            * @param middleName the user's new middle name
1844            * @param lastName the user's new last name
1845            * @param prefixId the user's new name prefix ID
1846            * @param suffixId the user's new name suffix ID
1847            * @param male whether user is male
1848            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
1849            for January)
1850            * @param birthdayDay the user's new birthday day
1851            * @param birthdayYear the user's birthday year
1852            * @param smsSn the user's new SMS screen name
1853            * @param aimSn the user's new AIM screen name
1854            * @param facebookSn the user's new Facebook screen name
1855            * @param icqSn the user's new ICQ screen name
1856            * @param jabberSn the user's new Jabber screen name
1857            * @param msnSn the user's new MSN screen name
1858            * @param mySpaceSn the user's new MySpace screen name
1859            * @param skypeSn the user's new Skype screen name
1860            * @param twitterSn the user's new Twitter screen name
1861            * @param ymSn the user's new Yahoo! Messenger screen name
1862            * @param jobTitle the user's new job title
1863            * @param groupIds the primary keys of the user's groups
1864            * @param organizationIds the primary keys of the user's organizations
1865            * @param roleIds the primary keys of the user's roles
1866            * @param userGroupRoles the user user's group roles
1867            * @param userGroupIds the primary keys of the user's user groups
1868            * @param serviceContext the service context to be applied (optionally
1869            <code>null</code>). Can set the UUID (with the <code>uuid</code>
1870            attribute), asset category IDs, asset tag names, and expando
1871            bridge attributes for the user.
1872            * @return the user
1873            * @throws PortalException if a user with the primary key could not be
1874            found, if the new information was invalid, if the current user
1875            did not have permission to update the user, or if the operation
1876            was not allowed by the membership policy
1877            */
1878            public static com.liferay.portal.model.UserSoap updateUser(long userId,
1879                    java.lang.String oldPassword, java.lang.String newPassword1,
1880                    java.lang.String newPassword2, boolean passwordReset,
1881                    java.lang.String reminderQueryQuestion,
1882                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
1883                    java.lang.String emailAddress, long facebookId,
1884                    java.lang.String openId, java.lang.String languageId,
1885                    java.lang.String timeZoneId, java.lang.String greeting,
1886                    java.lang.String comments, java.lang.String firstName,
1887                    java.lang.String middleName, java.lang.String lastName, int prefixId,
1888                    int suffixId, boolean male, int birthdayMonth, int birthdayDay,
1889                    int birthdayYear, java.lang.String smsSn, java.lang.String aimSn,
1890                    java.lang.String facebookSn, java.lang.String icqSn,
1891                    java.lang.String jabberSn, java.lang.String msnSn,
1892                    java.lang.String mySpaceSn, java.lang.String skypeSn,
1893                    java.lang.String twitterSn, java.lang.String ymSn,
1894                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
1895                    long[] roleIds,
1896                    com.liferay.portal.model.UserGroupRoleSoap[] userGroupRoles,
1897                    long[] userGroupIds,
1898                    com.liferay.portal.service.ServiceContext serviceContext)
1899                    throws RemoteException {
1900                    try {
1901                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateUser(userId,
1902                                            oldPassword, newPassword1, newPassword2, passwordReset,
1903                                            reminderQueryQuestion, reminderQueryAnswer, screenName,
1904                                            emailAddress, facebookId, openId, languageId, timeZoneId,
1905                                            greeting, comments, firstName, middleName, lastName,
1906                                            prefixId, suffixId, male, birthdayMonth, birthdayDay,
1907                                            birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn,
1908                                            msnSn, mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle,
1909                                            groupIds, organizationIds, roleIds,
1910                                            com.liferay.portal.model.impl.UserGroupRoleModelImpl.toModels(
1911                                                    userGroupRoles), userGroupIds, serviceContext);
1912    
1913                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1914                    }
1915                    catch (Exception e) {
1916                            _log.error(e, e);
1917    
1918                            throw new RemoteException(e.getMessage());
1919                    }
1920            }
1921    
1922            private static Log _log = LogFactoryUtil.getLog(UserServiceSoap.class);
1923    }