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 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 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, long prefixId, long 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, long prefixId, long 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, long prefixId, long 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, long prefixId, long 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            public static com.liferay.portal.model.UserSoap getCurrentUser()
650                    throws RemoteException {
651                    try {
652                            com.liferay.portal.model.User returnValue = UserServiceUtil.getCurrentUser();
653    
654                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
655                    }
656                    catch (Exception e) {
657                            _log.error(e, e);
658    
659                            throw new RemoteException(e.getMessage());
660                    }
661            }
662    
663            /**
664            * Returns the primary keys of all the users belonging to the group.
665            *
666            * @param groupId the primary key of the group
667            * @return the primary keys of the users belonging to the group
668            * @throws PortalException if the current user did not have permission to
669            view group assignments
670            */
671            public static long[] getGroupUserIds(long groupId)
672                    throws RemoteException {
673                    try {
674                            long[] returnValue = UserServiceUtil.getGroupUserIds(groupId);
675    
676                            return returnValue;
677                    }
678                    catch (Exception e) {
679                            _log.error(e, e);
680    
681                            throw new RemoteException(e.getMessage());
682                    }
683            }
684    
685            /**
686            * Returns all the users belonging to the group.
687            *
688            * @param groupId the primary key of the group
689            * @return the users belonging to the group
690            * @throws PortalException if the current user did not have permission to
691            view group assignments
692            */
693            public static com.liferay.portal.model.UserSoap[] getGroupUsers(
694                    long groupId) throws RemoteException {
695                    try {
696                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getGroupUsers(groupId);
697    
698                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
699                    }
700                    catch (Exception e) {
701                            _log.error(e, e);
702    
703                            throw new RemoteException(e.getMessage());
704                    }
705            }
706    
707            /**
708            * Returns the primary keys of all the users belonging to the organization.
709            *
710            * @param organizationId the primary key of the organization
711            * @return the primary keys of the users belonging to the organization
712            * @throws PortalException if the current user did not have permission to
713            view organization assignments
714            */
715            public static long[] getOrganizationUserIds(long organizationId)
716                    throws RemoteException {
717                    try {
718                            long[] returnValue = UserServiceUtil.getOrganizationUserIds(organizationId);
719    
720                            return returnValue;
721                    }
722                    catch (Exception e) {
723                            _log.error(e, e);
724    
725                            throw new RemoteException(e.getMessage());
726                    }
727            }
728    
729            /**
730            * Returns all the users belonging to the organization.
731            *
732            * @param organizationId the primary key of the organization
733            * @return users belonging to the organization
734            * @throws PortalException if the current user did not have permission to
735            view organization assignments
736            */
737            public static com.liferay.portal.model.UserSoap[] getOrganizationUsers(
738                    long organizationId) throws RemoteException {
739                    try {
740                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getOrganizationUsers(organizationId);
741    
742                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
743                    }
744                    catch (Exception e) {
745                            _log.error(e, e);
746    
747                            throw new RemoteException(e.getMessage());
748                    }
749            }
750    
751            /**
752            * Returns the primary keys of all the users belonging to the role.
753            *
754            * @param roleId the primary key of the role
755            * @return the primary keys of the users belonging to the role
756            * @throws PortalException if the current user did not have permission to
757            view role members
758            */
759            public static long[] getRoleUserIds(long roleId) throws RemoteException {
760                    try {
761                            long[] returnValue = UserServiceUtil.getRoleUserIds(roleId);
762    
763                            return returnValue;
764                    }
765                    catch (Exception e) {
766                            _log.error(e, e);
767    
768                            throw new RemoteException(e.getMessage());
769                    }
770            }
771    
772            /**
773            * Returns the user with the email address.
774            *
775            * @param companyId the primary key of the user's company
776            * @param emailAddress the user's email address
777            * @return the user with the email address
778            * @throws PortalException if a user with the email address could not be
779            found or if the current user did not have permission to view the
780            user
781            */
782            public static com.liferay.portal.model.UserSoap getUserByEmailAddress(
783                    long companyId, java.lang.String emailAddress)
784                    throws RemoteException {
785                    try {
786                            com.liferay.portal.model.User returnValue = UserServiceUtil.getUserByEmailAddress(companyId,
787                                            emailAddress);
788    
789                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
790                    }
791                    catch (Exception e) {
792                            _log.error(e, e);
793    
794                            throw new RemoteException(e.getMessage());
795                    }
796            }
797    
798            /**
799            * Returns the user with the primary key.
800            *
801            * @param userId the primary key of the user
802            * @return the user with the primary key
803            * @throws PortalException if a user with the primary key could not be found
804            or if the current user did not have permission to view the user
805            */
806            public static com.liferay.portal.model.UserSoap getUserById(long userId)
807                    throws RemoteException {
808                    try {
809                            com.liferay.portal.model.User returnValue = UserServiceUtil.getUserById(userId);
810    
811                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
812                    }
813                    catch (Exception e) {
814                            _log.error(e, e);
815    
816                            throw new RemoteException(e.getMessage());
817                    }
818            }
819    
820            /**
821            * Returns the user with the screen name.
822            *
823            * @param companyId the primary key of the user's company
824            * @param screenName the user's screen name
825            * @return the user with the screen name
826            * @throws PortalException if a user with the screen name could not be found
827            or if the current user did not have permission to view the user
828            */
829            public static com.liferay.portal.model.UserSoap getUserByScreenName(
830                    long companyId, java.lang.String screenName) throws RemoteException {
831                    try {
832                            com.liferay.portal.model.User returnValue = UserServiceUtil.getUserByScreenName(companyId,
833                                            screenName);
834    
835                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
836                    }
837                    catch (Exception e) {
838                            _log.error(e, e);
839    
840                            throw new RemoteException(e.getMessage());
841                    }
842            }
843    
844            public static com.liferay.portal.model.UserSoap[] getUserGroupUsers(
845                    long userGroupId) throws RemoteException {
846                    try {
847                            java.util.List<com.liferay.portal.model.User> returnValue = UserServiceUtil.getUserGroupUsers(userGroupId);
848    
849                            return com.liferay.portal.model.UserSoap.toSoapModels(returnValue);
850                    }
851                    catch (Exception e) {
852                            _log.error(e, e);
853    
854                            throw new RemoteException(e.getMessage());
855                    }
856            }
857    
858            /**
859            * Returns the primary key of the user with the email address.
860            *
861            * @param companyId the primary key of the user's company
862            * @param emailAddress the user's email address
863            * @return the primary key of the user with the email address
864            * @throws PortalException if a user with the email address could not be
865            found
866            */
867            public static long getUserIdByEmailAddress(long companyId,
868                    java.lang.String emailAddress) throws RemoteException {
869                    try {
870                            long returnValue = UserServiceUtil.getUserIdByEmailAddress(companyId,
871                                            emailAddress);
872    
873                            return returnValue;
874                    }
875                    catch (Exception e) {
876                            _log.error(e, e);
877    
878                            throw new RemoteException(e.getMessage());
879                    }
880            }
881    
882            /**
883            * Returns the primary key of the user with the screen name.
884            *
885            * @param companyId the primary key of the user's company
886            * @param screenName the user's screen name
887            * @return the primary key of the user with the screen name
888            * @throws PortalException if a user with the screen name could not be found
889            */
890            public static long getUserIdByScreenName(long companyId,
891                    java.lang.String screenName) throws RemoteException {
892                    try {
893                            long returnValue = UserServiceUtil.getUserIdByScreenName(companyId,
894                                            screenName);
895    
896                            return returnValue;
897                    }
898                    catch (Exception e) {
899                            _log.error(e, e);
900    
901                            throw new RemoteException(e.getMessage());
902                    }
903            }
904    
905            /**
906            * Returns <code>true</code> if the user is a member of the group.
907            *
908            * @param groupId the primary key of the group
909            * @param userId the primary key of the user
910            * @return <code>true</code> if the user is a member of the group;
911            <code>false</code> otherwise
912            * @throws PortalException if the current user did not have permission to
913            view the user or group members
914            */
915            public static boolean hasGroupUser(long groupId, long userId)
916                    throws RemoteException {
917                    try {
918                            boolean returnValue = UserServiceUtil.hasGroupUser(groupId, userId);
919    
920                            return returnValue;
921                    }
922                    catch (Exception e) {
923                            _log.error(e, e);
924    
925                            throw new RemoteException(e.getMessage());
926                    }
927            }
928    
929            /**
930            * Returns <code>true</code> if the user is a member of the role.
931            *
932            * @param roleId the primary key of the role
933            * @param userId the primary key of the user
934            * @return <code>true</code> if the user is a member of the role;
935            <code>false</code> otherwise
936            * @throws PortalException if the current user did not have permission to
937            view the user or role members
938            */
939            public static boolean hasRoleUser(long roleId, long userId)
940                    throws RemoteException {
941                    try {
942                            boolean returnValue = UserServiceUtil.hasRoleUser(roleId, userId);
943    
944                            return returnValue;
945                    }
946                    catch (Exception e) {
947                            _log.error(e, e);
948    
949                            throw new RemoteException(e.getMessage());
950                    }
951            }
952    
953            /**
954            * Returns <code>true</code> if the user has the role with the name,
955            * optionally through inheritance.
956            *
957            * @param companyId the primary key of the role's company
958            * @param name the name of the role (must be a regular role, not an
959            organization, site or provider role)
960            * @param userId the primary key of the user
961            * @param inherited whether to include roles inherited from organizations,
962            sites, etc.
963            * @return <code>true</code> if the user has the role; <code>false</code>
964            otherwise
965            * @throws PortalException if a role with the name could not be found
966            */
967            public static boolean hasRoleUser(long companyId, java.lang.String name,
968                    long userId, boolean inherited) throws RemoteException {
969                    try {
970                            boolean returnValue = UserServiceUtil.hasRoleUser(companyId, name,
971                                            userId, inherited);
972    
973                            return returnValue;
974                    }
975                    catch (Exception e) {
976                            _log.error(e, e);
977    
978                            throw new RemoteException(e.getMessage());
979                    }
980            }
981    
982            /**
983            * Sends a password notification email to the user matching the email
984            * address. The portal's settings determine whether a password is sent
985            * explicitly or whether a link for resetting the user's password is sent.
986            * The method sends the email asynchronously and returns before the email is
987            * sent.
988            *
989            * <p>
990            * The content of the notification email is specified with the
991            * <code>admin.email.password</code> portal property keys. They can be
992            * overridden via a <code>portal-ext.properties</code> file or modified
993            * through the Portal Settings UI.
994            * </p>
995            *
996            * @param companyId the primary key of the user's company
997            * @param emailAddress the user's email address
998            * @return <code>true</code> if the notification email includes a new
999            password; <code>false</code> if the notification email only
1000            contains a reset link
1001            * @throws PortalException if a user with the email address could not be
1002            found
1003            */
1004            public static boolean sendPasswordByEmailAddress(long companyId,
1005                    java.lang.String emailAddress) throws RemoteException {
1006                    try {
1007                            boolean returnValue = UserServiceUtil.sendPasswordByEmailAddress(companyId,
1008                                            emailAddress);
1009    
1010                            return returnValue;
1011                    }
1012                    catch (Exception e) {
1013                            _log.error(e, e);
1014    
1015                            throw new RemoteException(e.getMessage());
1016                    }
1017            }
1018    
1019            /**
1020            * Sends a password notification email to the user matching the screen name.
1021            * The portal's settings determine whether a password is sent explicitly or
1022            * whether a link for resetting the user's password is sent. The method
1023            * sends the email asynchronously and returns before the email is sent.
1024            *
1025            * <p>
1026            * The content of the notification email is specified with the
1027            * <code>admin.email.password</code> portal property keys. They can be
1028            * overridden via a <code>portal-ext.properties</code> file or modified
1029            * through the Portal Settings UI.
1030            * </p>
1031            *
1032            * @param companyId the primary key of the user's company
1033            * @param screenName the user's screen name
1034            * @return <code>true</code> if the notification email includes a new
1035            password; <code>false</code> if the notification email only
1036            contains a reset link
1037            * @throws PortalException if a user with the screen name could not be found
1038            */
1039            public static boolean sendPasswordByScreenName(long companyId,
1040                    java.lang.String screenName) throws RemoteException {
1041                    try {
1042                            boolean returnValue = UserServiceUtil.sendPasswordByScreenName(companyId,
1043                                            screenName);
1044    
1045                            return returnValue;
1046                    }
1047                    catch (Exception e) {
1048                            _log.error(e, e);
1049    
1050                            throw new RemoteException(e.getMessage());
1051                    }
1052            }
1053    
1054            /**
1055            * Sends a password notification email to the user matching the ID. The
1056            * portal's settings determine whether a password is sent explicitly or
1057            * whether a link for resetting the user's password is sent. The method
1058            * sends the email asynchronously and returns before the email is sent.
1059            *
1060            * <p>
1061            * The content of the notification email is specified with the
1062            * <code>admin.email.password</code> portal property keys. They can be
1063            * overridden via a <code>portal-ext.properties</code> file or modified
1064            * through the Portal Settings UI.
1065            * </p>
1066            *
1067            * @param userId the user's primary key
1068            * @return <code>true</code> if the notification email includes a new
1069            password; <code>false</code> if the notification email only
1070            contains a reset link
1071            * @throws PortalException if a user with the user ID could not be found
1072            */
1073            public static boolean sendPasswordByUserId(long userId)
1074                    throws RemoteException {
1075                    try {
1076                            boolean returnValue = UserServiceUtil.sendPasswordByUserId(userId);
1077    
1078                            return returnValue;
1079                    }
1080                    catch (Exception e) {
1081                            _log.error(e, e);
1082    
1083                            throw new RemoteException(e.getMessage());
1084                    }
1085            }
1086    
1087            /**
1088            * Sets the users in the role, removing and adding users to the role as
1089            * necessary.
1090            *
1091            * @param roleId the primary key of the role
1092            * @param userIds the primary keys of the users
1093            * @throws PortalException if the current user did not have permission to
1094            assign role members or if the operation was not allowed by the
1095            membership policy
1096            */
1097            public static void setRoleUsers(long roleId, long[] userIds)
1098                    throws RemoteException {
1099                    try {
1100                            UserServiceUtil.setRoleUsers(roleId, userIds);
1101                    }
1102                    catch (Exception e) {
1103                            _log.error(e, e);
1104    
1105                            throw new RemoteException(e.getMessage());
1106                    }
1107            }
1108    
1109            /**
1110            * Sets the users in the user group, removing and adding users to the user
1111            * group as necessary.
1112            *
1113            * @param userGroupId the primary key of the user group
1114            * @param userIds the primary keys of the users
1115            * @throws PortalException if the current user did not have permission to
1116            assign group members
1117            */
1118            public static void setUserGroupUsers(long userGroupId, long[] userIds)
1119                    throws RemoteException {
1120                    try {
1121                            UserServiceUtil.setUserGroupUsers(userGroupId, userIds);
1122                    }
1123                    catch (Exception e) {
1124                            _log.error(e, e);
1125    
1126                            throw new RemoteException(e.getMessage());
1127                    }
1128            }
1129    
1130            /**
1131            * Removes the users from the teams of a group.
1132            *
1133            * @param groupId the primary key of the group
1134            * @param userIds the primary keys of the users
1135            * @throws PortalException if the current user did not have permission to
1136            modify user group assignments
1137            */
1138            public static void unsetGroupTeamsUsers(long groupId, long[] userIds)
1139                    throws RemoteException {
1140                    try {
1141                            UserServiceUtil.unsetGroupTeamsUsers(groupId, userIds);
1142                    }
1143                    catch (Exception e) {
1144                            _log.error(e, e);
1145    
1146                            throw new RemoteException(e.getMessage());
1147                    }
1148            }
1149    
1150            /**
1151            * Removes the users from the group.
1152            *
1153            * @param groupId the primary key of the group
1154            * @param userIds the primary keys of the users
1155            * @param serviceContext the service context to be applied (optionally
1156            <code>null</code>)
1157            * @throws PortalException if the current user did not have permission to
1158            modify group assignments or if the operation was not allowed by
1159            the membership policy
1160            */
1161            public static void unsetGroupUsers(long groupId, long[] userIds,
1162                    com.liferay.portal.service.ServiceContext serviceContext)
1163                    throws RemoteException {
1164                    try {
1165                            UserServiceUtil.unsetGroupUsers(groupId, userIds, serviceContext);
1166                    }
1167                    catch (Exception e) {
1168                            _log.error(e, e);
1169    
1170                            throw new RemoteException(e.getMessage());
1171                    }
1172            }
1173    
1174            /**
1175            * Removes the users from the organization.
1176            *
1177            * @param organizationId the primary key of the organization
1178            * @param userIds the primary keys of the users
1179            * @throws PortalException if the current user did not have permission to
1180            modify organization assignments or if the operation was not
1181            allowed by the membership policy
1182            */
1183            public static void unsetOrganizationUsers(long organizationId,
1184                    long[] userIds) throws RemoteException {
1185                    try {
1186                            UserServiceUtil.unsetOrganizationUsers(organizationId, userIds);
1187                    }
1188                    catch (Exception e) {
1189                            _log.error(e, e);
1190    
1191                            throw new RemoteException(e.getMessage());
1192                    }
1193            }
1194    
1195            /**
1196            * Removes the users from the password policy.
1197            *
1198            * @param passwordPolicyId the primary key of the password policy
1199            * @param userIds the primary keys of the users
1200            * @throws PortalException if the current user did not have permission to
1201            modify policy assignments
1202            */
1203            public static void unsetPasswordPolicyUsers(long passwordPolicyId,
1204                    long[] userIds) throws RemoteException {
1205                    try {
1206                            UserServiceUtil.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
1207                    }
1208                    catch (Exception e) {
1209                            _log.error(e, e);
1210    
1211                            throw new RemoteException(e.getMessage());
1212                    }
1213            }
1214    
1215            /**
1216            * Removes the users from the role.
1217            *
1218            * @param roleId the primary key of the role
1219            * @param userIds the primary keys of the users
1220            * @throws PortalException if the current user did not have permission to
1221            modify role assignments or if the operation was not allowed by
1222            the membership policy
1223            */
1224            public static void unsetRoleUsers(long roleId, long[] userIds)
1225                    throws RemoteException {
1226                    try {
1227                            UserServiceUtil.unsetRoleUsers(roleId, userIds);
1228                    }
1229                    catch (Exception e) {
1230                            _log.error(e, e);
1231    
1232                            throw new RemoteException(e.getMessage());
1233                    }
1234            }
1235    
1236            /**
1237            * Removes the users from the team.
1238            *
1239            * @param teamId the primary key of the team
1240            * @param userIds the primary keys of the users
1241            * @throws PortalException if the current user did not have permission to
1242            modify team assignments
1243            */
1244            public static void unsetTeamUsers(long teamId, long[] userIds)
1245                    throws RemoteException {
1246                    try {
1247                            UserServiceUtil.unsetTeamUsers(teamId, userIds);
1248                    }
1249                    catch (Exception e) {
1250                            _log.error(e, e);
1251    
1252                            throw new RemoteException(e.getMessage());
1253                    }
1254            }
1255    
1256            /**
1257            * Removes the users from the user group.
1258            *
1259            * @param userGroupId the primary key of the user group
1260            * @param userIds the primary keys of the users
1261            * @throws PortalException if the current user did not have permission to
1262            modify user group assignments or if the operation was not allowed
1263            by the membership policy
1264            */
1265            public static void unsetUserGroupUsers(long userGroupId, long[] userIds)
1266                    throws RemoteException {
1267                    try {
1268                            UserServiceUtil.unsetUserGroupUsers(userGroupId, userIds);
1269                    }
1270                    catch (Exception e) {
1271                            _log.error(e, e);
1272    
1273                            throw new RemoteException(e.getMessage());
1274                    }
1275            }
1276    
1277            /**
1278            * Updates the user's response to the terms of use agreement.
1279            *
1280            * @param userId the primary key of the user
1281            * @param agreedToTermsOfUse whether the user has agree to the terms of use
1282            * @return the user
1283            * @throws PortalException if the current user did not have permission to
1284            update the user's agreement to terms-of-use
1285            */
1286            public static com.liferay.portal.model.UserSoap updateAgreedToTermsOfUse(
1287                    long userId, boolean agreedToTermsOfUse) throws RemoteException {
1288                    try {
1289                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateAgreedToTermsOfUse(userId,
1290                                            agreedToTermsOfUse);
1291    
1292                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1293                    }
1294                    catch (Exception e) {
1295                            _log.error(e, e);
1296    
1297                            throw new RemoteException(e.getMessage());
1298                    }
1299            }
1300    
1301            /**
1302            * Updates the user's email address.
1303            *
1304            * @param userId the primary key of the user
1305            * @param password the user's password
1306            * @param emailAddress1 the user's new email address
1307            * @param emailAddress2 the user's new email address confirmation
1308            * @param serviceContext the service context to be applied. Must set the
1309            portal URL, main path, primary key of the layout, remote address,
1310            remote host, and agent for the user.
1311            * @return the user
1312            * @throws PortalException if a user with the primary key could not be found
1313            or if the current user did not have permission to update the user
1314            */
1315            public static com.liferay.portal.model.UserSoap updateEmailAddress(
1316                    long userId, java.lang.String password, java.lang.String emailAddress1,
1317                    java.lang.String emailAddress2,
1318                    com.liferay.portal.service.ServiceContext serviceContext)
1319                    throws RemoteException {
1320                    try {
1321                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateEmailAddress(userId,
1322                                            password, emailAddress1, emailAddress2, serviceContext);
1323    
1324                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1325                    }
1326                    catch (Exception e) {
1327                            _log.error(e, e);
1328    
1329                            throw new RemoteException(e.getMessage());
1330                    }
1331            }
1332    
1333            /**
1334            * Updates a user account that was automatically created when a guest user
1335            * participated in an action (e.g. posting a comment) and only provided his
1336            * name and email address.
1337            *
1338            * @param companyId the primary key of the user's company
1339            * @param autoPassword whether a password should be automatically generated
1340            for the user
1341            * @param password1 the user's password
1342            * @param password2 the user's password confirmation
1343            * @param autoScreenName whether a screen name should be automatically
1344            generated for the user
1345            * @param screenName the user's screen name
1346            * @param emailAddress the user's email address
1347            * @param facebookId the user's facebook ID
1348            * @param openId the user's OpenID
1349            * @param locale the user's locale
1350            * @param firstName the user's first name
1351            * @param middleName the user's middle name
1352            * @param lastName the user's last name
1353            * @param prefixId the user's name prefix ID
1354            * @param suffixId the user's name suffix ID
1355            * @param male whether the user is male
1356            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
1357            January)
1358            * @param birthdayDay the user's birthday day
1359            * @param birthdayYear the user's birthday year
1360            * @param jobTitle the user's job title
1361            * @param updateUserInformation whether to update the user's information
1362            * @param sendEmail whether to send the user an email notification about
1363            their new account
1364            * @param serviceContext the service context to be applied (optionally
1365            <code>null</code>). Can set the expando bridge attributes for the
1366            user.
1367            * @return the user
1368            * @throws PortalException if the user's information was invalid or if the
1369            email address was reserved
1370            */
1371            public static com.liferay.portal.model.UserSoap updateIncompleteUser(
1372                    long companyId, boolean autoPassword, java.lang.String password1,
1373                    java.lang.String password2, boolean autoScreenName,
1374                    java.lang.String screenName, java.lang.String emailAddress,
1375                    long facebookId, java.lang.String openId, String locale,
1376                    java.lang.String firstName, java.lang.String middleName,
1377                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
1378                    int birthdayMonth, int birthdayDay, int birthdayYear,
1379                    java.lang.String jobTitle, boolean updateUserInformation,
1380                    boolean sendEmail,
1381                    com.liferay.portal.service.ServiceContext serviceContext)
1382                    throws RemoteException {
1383                    try {
1384                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateIncompleteUser(companyId,
1385                                            autoPassword, password1, password2, autoScreenName,
1386                                            screenName, emailAddress, facebookId, openId,
1387                                            LocaleUtil.fromLanguageId(locale), firstName, middleName,
1388                                            lastName, prefixId, suffixId, male, birthdayMonth,
1389                                            birthdayDay, birthdayYear, jobTitle, updateUserInformation,
1390                                            sendEmail, serviceContext);
1391    
1392                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1393                    }
1394                    catch (Exception e) {
1395                            _log.error(e, e);
1396    
1397                            throw new RemoteException(e.getMessage());
1398                    }
1399            }
1400    
1401            /**
1402            * Updates whether the user is locked out from logging in.
1403            *
1404            * @param userId the primary key of the user
1405            * @param lockout whether the user is locked out
1406            * @return the user
1407            * @throws PortalException if the user did not have permission to lock out
1408            the user
1409            */
1410            public static com.liferay.portal.model.UserSoap updateLockoutById(
1411                    long userId, boolean lockout) throws RemoteException {
1412                    try {
1413                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateLockoutById(userId,
1414                                            lockout);
1415    
1416                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1417                    }
1418                    catch (Exception e) {
1419                            _log.error(e, e);
1420    
1421                            throw new RemoteException(e.getMessage());
1422                    }
1423            }
1424    
1425            /**
1426            * Updates the user's OpenID.
1427            *
1428            * @param userId the primary key of the user
1429            * @param openId the new OpenID
1430            * @return the user
1431            * @throws PortalException if a user with the primary key could not be found
1432            or if the current user did not have permission to update the user
1433            */
1434            public static com.liferay.portal.model.UserSoap updateOpenId(long userId,
1435                    java.lang.String openId) throws RemoteException {
1436                    try {
1437                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateOpenId(userId,
1438                                            openId);
1439    
1440                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1441                    }
1442                    catch (Exception e) {
1443                            _log.error(e, e);
1444    
1445                            throw new RemoteException(e.getMessage());
1446                    }
1447            }
1448    
1449            /**
1450            * Sets the organizations that the user is in, removing and adding
1451            * organizations as necessary.
1452            *
1453            * @param userId the primary key of the user
1454            * @param organizationIds the primary keys of the organizations
1455            * @param serviceContext the service context to be applied. Must set
1456            whether user indexing is enabled.
1457            * @throws PortalException if a user with the primary key could not be found
1458            or if the current user did not have permission to update the user
1459            */
1460            public static void updateOrganizations(long userId, long[] organizationIds,
1461                    com.liferay.portal.service.ServiceContext serviceContext)
1462                    throws RemoteException {
1463                    try {
1464                            UserServiceUtil.updateOrganizations(userId, organizationIds,
1465                                    serviceContext);
1466                    }
1467                    catch (Exception e) {
1468                            _log.error(e, e);
1469    
1470                            throw new RemoteException(e.getMessage());
1471                    }
1472            }
1473    
1474            /**
1475            * Updates the user's password without tracking or validation of the change.
1476            *
1477            * @param userId the primary key of the user
1478            * @param password1 the user's new password
1479            * @param password2 the user's new password confirmation
1480            * @param passwordReset whether the user should be asked to reset their
1481            password the next time they log in
1482            * @return the user
1483            * @throws PortalException if a user with the primary key could not be found
1484            or if the current user did not have permission to update the user
1485            */
1486            public static com.liferay.portal.model.UserSoap updatePassword(
1487                    long userId, java.lang.String password1, java.lang.String password2,
1488                    boolean passwordReset) throws RemoteException {
1489                    try {
1490                            com.liferay.portal.model.User returnValue = UserServiceUtil.updatePassword(userId,
1491                                            password1, password2, passwordReset);
1492    
1493                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1494                    }
1495                    catch (Exception e) {
1496                            _log.error(e, e);
1497    
1498                            throw new RemoteException(e.getMessage());
1499                    }
1500            }
1501    
1502            /**
1503            * Updates the user's portrait image.
1504            *
1505            * @param userId the primary key of the user
1506            * @param bytes the new portrait image data
1507            * @return the user
1508            * @throws PortalException if a user with the primary key could not be
1509            found, if the new portrait was invalid, or if the current user
1510            did not have permission to update the user
1511            */
1512            public static com.liferay.portal.model.UserSoap updatePortrait(
1513                    long userId, byte[] bytes) throws RemoteException {
1514                    try {
1515                            com.liferay.portal.model.User returnValue = UserServiceUtil.updatePortrait(userId,
1516                                            bytes);
1517    
1518                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1519                    }
1520                    catch (Exception e) {
1521                            _log.error(e, e);
1522    
1523                            throw new RemoteException(e.getMessage());
1524                    }
1525            }
1526    
1527            /**
1528            * Updates the user's password reset question and answer.
1529            *
1530            * @param userId the primary key of the user
1531            * @param question the user's new password reset question
1532            * @param answer the user's new password reset answer
1533            * @return the user
1534            * @throws PortalException if a user with the primary key could not be
1535            found, if the new question or answer were invalid, or if the
1536            current user did not have permission to update the user
1537            */
1538            public static com.liferay.portal.model.UserSoap updateReminderQuery(
1539                    long userId, java.lang.String question, java.lang.String answer)
1540                    throws RemoteException {
1541                    try {
1542                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateReminderQuery(userId,
1543                                            question, answer);
1544    
1545                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1546                    }
1547                    catch (Exception e) {
1548                            _log.error(e, e);
1549    
1550                            throw new RemoteException(e.getMessage());
1551                    }
1552            }
1553    
1554            /**
1555            * Updates the user's screen name.
1556            *
1557            * @param userId the primary key of the user
1558            * @param screenName the user's new screen name
1559            * @return the user
1560            * @throws PortalException if a user with the primary key could not be
1561            found, if the new screen name was invalid, or if the current user
1562            did not have permission to update the user
1563            */
1564            public static com.liferay.portal.model.UserSoap updateScreenName(
1565                    long userId, java.lang.String screenName) throws RemoteException {
1566                    try {
1567                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateScreenName(userId,
1568                                            screenName);
1569    
1570                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1571                    }
1572                    catch (Exception e) {
1573                            _log.error(e, e);
1574    
1575                            throw new RemoteException(e.getMessage());
1576                    }
1577            }
1578    
1579            /**
1580            * Updates the user's workflow status.
1581            *
1582            * @param userId the primary key of the user
1583            * @param status the user's new workflow status
1584            * @return the user
1585            * @throws PortalException if a user with the primary key could not be
1586            found, if the current user was updating her own status to
1587            anything but {@link
1588            com.liferay.portal.kernel.workflow.WorkflowConstants#STATUS_APPROVED},
1589            or if the current user did not have permission to update the
1590            user's workflow status.
1591            * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int,
1592            ServiceContext)}
1593            */
1594            @Deprecated
1595            public static com.liferay.portal.model.UserSoap updateStatus(long userId,
1596                    int status) throws RemoteException {
1597                    try {
1598                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateStatus(userId,
1599                                            status);
1600    
1601                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1602                    }
1603                    catch (Exception e) {
1604                            _log.error(e, e);
1605    
1606                            throw new RemoteException(e.getMessage());
1607                    }
1608            }
1609    
1610            /**
1611            * Updates the user's workflow status.
1612            *
1613            * @param userId the primary key of the user
1614            * @param status the user's new workflow status
1615            * @param serviceContext the service context to be applied. You can specify
1616            an unencrypted custom password (used by an LDAP listener) for the
1617            user via attribute <code>passwordUnencrypted</code>.
1618            * @return the user
1619            * @throws PortalException if a user with the primary key could not be
1620            found, if the current user was updating her own status to
1621            anything but {@link
1622            com.liferay.portal.kernel.workflow.WorkflowConstants#STATUS_APPROVED},
1623            or if the current user did not have permission to update the
1624            user's workflow status.
1625            */
1626            public static com.liferay.portal.model.UserSoap updateStatus(long userId,
1627                    int status, com.liferay.portal.service.ServiceContext serviceContext)
1628                    throws RemoteException {
1629                    try {
1630                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateStatus(userId,
1631                                            status, serviceContext);
1632    
1633                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1634                    }
1635                    catch (Exception e) {
1636                            _log.error(e, e);
1637    
1638                            throw new RemoteException(e.getMessage());
1639                    }
1640            }
1641    
1642            /**
1643            * Updates the user with additional parameters.
1644            *
1645            * @param userId the primary key of the user
1646            * @param oldPassword the user's old password
1647            * @param newPassword1 the user's new password (optionally
1648            <code>null</code>)
1649            * @param newPassword2 the user's new password confirmation (optionally
1650            <code>null</code>)
1651            * @param passwordReset whether the user should be asked to reset their
1652            password the next time they login
1653            * @param reminderQueryQuestion the user's new password reset question
1654            * @param reminderQueryAnswer the user's new password reset answer
1655            * @param screenName the user's new screen name
1656            * @param emailAddress the user's new email address
1657            * @param facebookId the user's new Facebook ID
1658            * @param openId the user's new OpenID
1659            * @param portrait whether to update the user's portrait image
1660            * @param portraitBytes the new portrait image data
1661            * @param languageId the user's new language ID
1662            * @param timeZoneId the user's new time zone ID
1663            * @param greeting the user's new greeting
1664            * @param comments the user's new comments
1665            * @param firstName the user's new first name
1666            * @param middleName the user's new middle name
1667            * @param lastName the user's new last name
1668            * @param prefixId the user's new name prefix ID
1669            * @param suffixId the user's new name suffix ID
1670            * @param male whether user is male
1671            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
1672            for January)
1673            * @param birthdayDay the user's new birthday day
1674            * @param birthdayYear the user's birthday year
1675            * @param smsSn the user's new SMS screen name
1676            * @param aimSn the user's new AIM screen name
1677            * @param facebookSn the user's new Facebook screen name
1678            * @param icqSn the user's new ICQ screen name
1679            * @param jabberSn the user's new Jabber screen name
1680            * @param msnSn the user's new MSN screen name
1681            * @param mySpaceSn the user's new MySpace screen name
1682            * @param skypeSn the user's new Skype screen name
1683            * @param twitterSn the user's new Twitter screen name
1684            * @param ymSn the user's new Yahoo! Messenger screen name
1685            * @param jobTitle the user's new job title
1686            * @param groupIds the primary keys of the user's groups
1687            * @param organizationIds the primary keys of the user's organizations
1688            * @param roleIds the primary keys of the user's roles
1689            * @param userGroupRoles the user user's group roles
1690            * @param userGroupIds the primary keys of the user's user groups
1691            * @param addresses the user's addresses
1692            * @param emailAddresses the user's email addresses
1693            * @param phones the user's phone numbers
1694            * @param websites the user's websites
1695            * @param announcementsDelivers the announcements deliveries
1696            * @param serviceContext the service context to be applied (optionally
1697            <code>null</code>). Can set the UUID (with the <code>uuid</code>
1698            attribute), asset category IDs, asset tag names, and expando
1699            bridge attributes for the user.
1700            * @return the user
1701            * @throws PortalException if a user with the primary key could not be
1702            found, if the new information was invalid, if the current user
1703            did not have permission to update the user, or if the operation
1704            was not allowed by the membership policy
1705            */
1706            public static com.liferay.portal.model.UserSoap updateUser(long userId,
1707                    java.lang.String oldPassword, java.lang.String newPassword1,
1708                    java.lang.String newPassword2, boolean passwordReset,
1709                    java.lang.String reminderQueryQuestion,
1710                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
1711                    java.lang.String emailAddress, long facebookId,
1712                    java.lang.String openId, boolean portrait, byte[] portraitBytes,
1713                    java.lang.String languageId, java.lang.String timeZoneId,
1714                    java.lang.String greeting, java.lang.String comments,
1715                    java.lang.String firstName, java.lang.String middleName,
1716                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
1717                    int birthdayMonth, int birthdayDay, int birthdayYear,
1718                    java.lang.String smsSn, java.lang.String aimSn,
1719                    java.lang.String facebookSn, java.lang.String icqSn,
1720                    java.lang.String jabberSn, java.lang.String msnSn,
1721                    java.lang.String mySpaceSn, java.lang.String skypeSn,
1722                    java.lang.String twitterSn, java.lang.String ymSn,
1723                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
1724                    long[] roleIds,
1725                    com.liferay.portal.model.UserGroupRoleSoap[] userGroupRoles,
1726                    long[] userGroupIds, com.liferay.portal.model.AddressSoap[] addresses,
1727                    com.liferay.portal.model.EmailAddressSoap[] emailAddresses,
1728                    com.liferay.portal.model.PhoneSoap[] phones,
1729                    com.liferay.portal.model.WebsiteSoap[] websites,
1730                    com.liferay.portlet.announcements.model.AnnouncementsDeliverySoap[] announcementsDelivers,
1731                    com.liferay.portal.service.ServiceContext serviceContext)
1732                    throws RemoteException {
1733                    try {
1734                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateUser(userId,
1735                                            oldPassword, newPassword1, newPassword2, passwordReset,
1736                                            reminderQueryQuestion, reminderQueryAnswer, screenName,
1737                                            emailAddress, facebookId, openId, portrait, portraitBytes,
1738                                            languageId, timeZoneId, greeting, comments, firstName,
1739                                            middleName, lastName, prefixId, suffixId, male,
1740                                            birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn,
1741                                            facebookSn, icqSn, jabberSn, msnSn, mySpaceSn, skypeSn,
1742                                            twitterSn, ymSn, jobTitle, groupIds, organizationIds,
1743                                            roleIds,
1744                                            com.liferay.portal.model.impl.UserGroupRoleModelImpl.toModels(
1745                                                    userGroupRoles), userGroupIds,
1746                                            com.liferay.portal.model.impl.AddressModelImpl.toModels(
1747                                                    addresses),
1748                                            com.liferay.portal.model.impl.EmailAddressModelImpl.toModels(
1749                                                    emailAddresses),
1750                                            com.liferay.portal.model.impl.PhoneModelImpl.toModels(
1751                                                    phones),
1752                                            com.liferay.portal.model.impl.WebsiteModelImpl.toModels(
1753                                                    websites),
1754                                            com.liferay.portlet.announcements.model.impl.AnnouncementsDeliveryModelImpl.toModels(
1755                                                    announcementsDelivers), serviceContext);
1756    
1757                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1758                    }
1759                    catch (Exception e) {
1760                            _log.error(e, e);
1761    
1762                            throw new RemoteException(e.getMessage());
1763                    }
1764            }
1765    
1766            /**
1767            * Updates the user with additional parameters.
1768            *
1769            * @param userId the primary key of the user
1770            * @param oldPassword the user's old password
1771            * @param newPassword1 the user's new password (optionally
1772            <code>null</code>)
1773            * @param newPassword2 the user's new password confirmation (optionally
1774            <code>null</code>)
1775            * @param passwordReset whether the user should be asked to reset their
1776            password the next time they login
1777            * @param reminderQueryQuestion the user's new password reset question
1778            * @param reminderQueryAnswer the user's new password reset answer
1779            * @param screenName the user's new screen name
1780            * @param emailAddress the user's new email address
1781            * @param facebookId the user's new Facebook ID
1782            * @param openId the user's new OpenID
1783            * @param languageId the user's new language ID
1784            * @param timeZoneId the user's new time zone ID
1785            * @param greeting the user's new greeting
1786            * @param comments the user's new comments
1787            * @param firstName the user's new first name
1788            * @param middleName the user's new middle name
1789            * @param lastName the user's new last name
1790            * @param prefixId the user's new name prefix ID
1791            * @param suffixId the user's new name suffix ID
1792            * @param male whether user is male
1793            * @param birthdayMonth the user's new birthday month (0-based, meaning
1794            0 for January)
1795            * @param birthdayDay the user's new birthday day
1796            * @param birthdayYear the user's birthday year
1797            * @param smsSn the user's new SMS screen name
1798            * @param aimSn the user's new AIM screen name
1799            * @param facebookSn the user's new Facebook screen name
1800            * @param icqSn the user's new ICQ screen name
1801            * @param jabberSn the user's new Jabber screen name
1802            * @param msnSn the user's new MSN screen name
1803            * @param mySpaceSn the user's new MySpace screen name
1804            * @param skypeSn the user's new Skype screen name
1805            * @param twitterSn the user's new Twitter screen name
1806            * @param ymSn the user's new Yahoo! Messenger screen name
1807            * @param jobTitle the user's new job title
1808            * @param groupIds the primary keys of the user's groups
1809            * @param organizationIds the primary keys of the user's organizations
1810            * @param roleIds the primary keys of the user's roles
1811            * @param userGroupRoles the user user's group roles
1812            * @param userGroupIds the primary keys of the user's user groups
1813            * @param addresses the user's addresses
1814            * @param emailAddresses the user's email addresses
1815            * @param phones the user's phone numbers
1816            * @param websites the user's websites
1817            * @param announcementsDelivers the announcements deliveries
1818            * @param serviceContext the service context to be applied (optionally
1819            <code>null</code>). Can set the UUID (with the
1820            <code>uuid</code> attribute), asset category IDs, asset tag
1821            names, and expando bridge attributes for the user.
1822            * @return the user
1823            * @throws PortalException if a user with the primary key could not be
1824            found, if the new information was invalid, if the current
1825            user did not have permission to update the user, or if the
1826            operation was not allowed by the membership policy
1827            * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String,
1828            String, String, boolean, String, String, String, String,
1829            long, String, boolean, byte[], String, String, String,
1830            String, String, String, String, int, int, boolean, int, int,
1831            int, String, String, String, String, String, String, String,
1832            String, String, String, String, long[], long[], long[],
1833            java.util.List, long[], java.util.List, java.util.List,
1834            java.util.List, java.util.List, java.util.List,
1835            com.liferay.portal.service.ServiceContext)}
1836            */
1837            @Deprecated
1838            public static com.liferay.portal.model.UserSoap updateUser(long userId,
1839                    java.lang.String oldPassword, java.lang.String newPassword1,
1840                    java.lang.String newPassword2, boolean passwordReset,
1841                    java.lang.String reminderQueryQuestion,
1842                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
1843                    java.lang.String emailAddress, long facebookId,
1844                    java.lang.String openId, java.lang.String languageId,
1845                    java.lang.String timeZoneId, java.lang.String greeting,
1846                    java.lang.String comments, java.lang.String firstName,
1847                    java.lang.String middleName, java.lang.String lastName, long prefixId,
1848                    long suffixId, boolean male, int birthdayMonth, int birthdayDay,
1849                    int birthdayYear, java.lang.String smsSn, java.lang.String aimSn,
1850                    java.lang.String facebookSn, java.lang.String icqSn,
1851                    java.lang.String jabberSn, java.lang.String msnSn,
1852                    java.lang.String mySpaceSn, java.lang.String skypeSn,
1853                    java.lang.String twitterSn, java.lang.String ymSn,
1854                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
1855                    long[] roleIds,
1856                    com.liferay.portal.model.UserGroupRoleSoap[] userGroupRoles,
1857                    long[] userGroupIds, com.liferay.portal.model.AddressSoap[] addresses,
1858                    com.liferay.portal.model.EmailAddressSoap[] emailAddresses,
1859                    com.liferay.portal.model.PhoneSoap[] phones,
1860                    com.liferay.portal.model.WebsiteSoap[] websites,
1861                    com.liferay.portlet.announcements.model.AnnouncementsDeliverySoap[] announcementsDelivers,
1862                    com.liferay.portal.service.ServiceContext serviceContext)
1863                    throws RemoteException {
1864                    try {
1865                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateUser(userId,
1866                                            oldPassword, newPassword1, newPassword2, passwordReset,
1867                                            reminderQueryQuestion, reminderQueryAnswer, screenName,
1868                                            emailAddress, facebookId, openId, languageId, timeZoneId,
1869                                            greeting, comments, firstName, middleName, lastName,
1870                                            prefixId, suffixId, male, birthdayMonth, birthdayDay,
1871                                            birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn,
1872                                            msnSn, mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle,
1873                                            groupIds, organizationIds, roleIds,
1874                                            com.liferay.portal.model.impl.UserGroupRoleModelImpl.toModels(
1875                                                    userGroupRoles), userGroupIds,
1876                                            com.liferay.portal.model.impl.AddressModelImpl.toModels(
1877                                                    addresses),
1878                                            com.liferay.portal.model.impl.EmailAddressModelImpl.toModels(
1879                                                    emailAddresses),
1880                                            com.liferay.portal.model.impl.PhoneModelImpl.toModels(
1881                                                    phones),
1882                                            com.liferay.portal.model.impl.WebsiteModelImpl.toModels(
1883                                                    websites),
1884                                            com.liferay.portlet.announcements.model.impl.AnnouncementsDeliveryModelImpl.toModels(
1885                                                    announcementsDelivers), serviceContext);
1886    
1887                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1888                    }
1889                    catch (Exception e) {
1890                            _log.error(e, e);
1891    
1892                            throw new RemoteException(e.getMessage());
1893                    }
1894            }
1895    
1896            /**
1897            * Updates the user.
1898            *
1899            * @param userId the primary key of the user
1900            * @param oldPassword the user's old password
1901            * @param newPassword1 the user's new password (optionally
1902            <code>null</code>)
1903            * @param newPassword2 the user's new password confirmation (optionally
1904            <code>null</code>)
1905            * @param passwordReset whether the user should be asked to reset their
1906            password the next time they login
1907            * @param reminderQueryQuestion the user's new password reset question
1908            * @param reminderQueryAnswer the user's new password reset answer
1909            * @param screenName the user's new screen name
1910            * @param emailAddress the user's new email address
1911            * @param facebookId the user's new Facebook ID
1912            * @param openId the user's new OpenID
1913            * @param languageId the user's new language ID
1914            * @param timeZoneId the user's new time zone ID
1915            * @param greeting the user's new greeting
1916            * @param comments the user's new comments
1917            * @param firstName the user's new first name
1918            * @param middleName the user's new middle name
1919            * @param lastName the user's new last name
1920            * @param prefixId the user's new name prefix ID
1921            * @param suffixId the user's new name suffix ID
1922            * @param male whether user is male
1923            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
1924            for January)
1925            * @param birthdayDay the user's new birthday day
1926            * @param birthdayYear the user's birthday year
1927            * @param smsSn the user's new SMS screen name
1928            * @param aimSn the user's new AIM screen name
1929            * @param facebookSn the user's new Facebook screen name
1930            * @param icqSn the user's new ICQ screen name
1931            * @param jabberSn the user's new Jabber screen name
1932            * @param msnSn the user's new MSN screen name
1933            * @param mySpaceSn the user's new MySpace screen name
1934            * @param skypeSn the user's new Skype screen name
1935            * @param twitterSn the user's new Twitter screen name
1936            * @param ymSn the user's new Yahoo! Messenger screen name
1937            * @param jobTitle the user's new job title
1938            * @param groupIds the primary keys of the user's groups
1939            * @param organizationIds the primary keys of the user's organizations
1940            * @param roleIds the primary keys of the user's roles
1941            * @param userGroupRoles the user user's group roles
1942            * @param userGroupIds the primary keys of the user's user groups
1943            * @param serviceContext the service context to be applied (optionally
1944            <code>null</code>). Can set the UUID (with the <code>uuid</code>
1945            attribute), asset category IDs, asset tag names, and expando
1946            bridge attributes for the user.
1947            * @return the user
1948            * @throws PortalException if a user with the primary key could not be
1949            found, if the new information was invalid, if the current user
1950            did not have permission to update the user, or if the operation
1951            was not allowed by the membership policy
1952            */
1953            public static com.liferay.portal.model.UserSoap updateUser(long userId,
1954                    java.lang.String oldPassword, java.lang.String newPassword1,
1955                    java.lang.String newPassword2, boolean passwordReset,
1956                    java.lang.String reminderQueryQuestion,
1957                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
1958                    java.lang.String emailAddress, long facebookId,
1959                    java.lang.String openId, java.lang.String languageId,
1960                    java.lang.String timeZoneId, java.lang.String greeting,
1961                    java.lang.String comments, java.lang.String firstName,
1962                    java.lang.String middleName, java.lang.String lastName, long prefixId,
1963                    long suffixId, boolean male, int birthdayMonth, int birthdayDay,
1964                    int birthdayYear, java.lang.String smsSn, java.lang.String aimSn,
1965                    java.lang.String facebookSn, java.lang.String icqSn,
1966                    java.lang.String jabberSn, java.lang.String msnSn,
1967                    java.lang.String mySpaceSn, java.lang.String skypeSn,
1968                    java.lang.String twitterSn, java.lang.String ymSn,
1969                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
1970                    long[] roleIds,
1971                    com.liferay.portal.model.UserGroupRoleSoap[] userGroupRoles,
1972                    long[] userGroupIds,
1973                    com.liferay.portal.service.ServiceContext serviceContext)
1974                    throws RemoteException {
1975                    try {
1976                            com.liferay.portal.model.User returnValue = UserServiceUtil.updateUser(userId,
1977                                            oldPassword, newPassword1, newPassword2, passwordReset,
1978                                            reminderQueryQuestion, reminderQueryAnswer, screenName,
1979                                            emailAddress, facebookId, openId, languageId, timeZoneId,
1980                                            greeting, comments, firstName, middleName, lastName,
1981                                            prefixId, suffixId, male, birthdayMonth, birthdayDay,
1982                                            birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn,
1983                                            msnSn, mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle,
1984                                            groupIds, organizationIds, roleIds,
1985                                            com.liferay.portal.model.impl.UserGroupRoleModelImpl.toModels(
1986                                                    userGroupRoles), userGroupIds, serviceContext);
1987    
1988                            return com.liferay.portal.model.UserSoap.toSoapModel(returnValue);
1989                    }
1990                    catch (Exception e) {
1991                            _log.error(e, e);
1992    
1993                            throw new RemoteException(e.getMessage());
1994                    }
1995            }
1996    
1997            private static Log _log = LogFactoryUtil.getLog(UserServiceSoap.class);
1998    }