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;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.util.ReferenceRegistry;
021    
022    /**
023     * Provides the local service utility for User. This utility wraps
024     * {@link com.liferay.portal.service.impl.UserLocalServiceImpl} and is the
025     * primary access point for service operations in application layer code running
026     * on the local server. Methods of this service will not have security checks
027     * based on the propagated JAAS credentials because this service can only be
028     * accessed from within the same VM.
029     *
030     * @author Brian Wing Shun Chan
031     * @see UserLocalService
032     * @see com.liferay.portal.service.base.UserLocalServiceBaseImpl
033     * @see com.liferay.portal.service.impl.UserLocalServiceImpl
034     * @generated
035     */
036    @ProviderType
037    public class UserLocalServiceUtil {
038            /*
039             * NOTE FOR DEVELOPERS:
040             *
041             * Never modify this class directly. Add custom service methods to {@link com.liferay.portal.service.impl.UserLocalServiceImpl} and rerun ServiceBuilder to regenerate this class.
042             */
043    
044            /**
045            * Adds a default admin user for the company.
046            *
047            * @param companyId the primary key of the user's company
048            * @param screenName the user's screen name
049            * @param emailAddress the user's email address
050            * @param locale the user's locale
051            * @param firstName the user's first name
052            * @param middleName the user's middle name
053            * @param lastName the user's last name
054            * @return the new default admin user
055            */
056            public static com.liferay.portal.model.User addDefaultAdminUser(
057                    long companyId, java.lang.String screenName,
058                    java.lang.String emailAddress, java.util.Locale locale,
059                    java.lang.String firstName, java.lang.String middleName,
060                    java.lang.String lastName)
061                    throws com.liferay.portal.kernel.exception.PortalException {
062                    return getService()
063                                       .addDefaultAdminUser(companyId, screenName, emailAddress,
064                            locale, firstName, middleName, lastName);
065            }
066    
067            /**
068            * Adds the user to the default groups, unless the user is already in these
069            * groups. The default groups can be specified in
070            * <code>portal.properties</code> with the key
071            * <code>admin.default.group.names</code>.
072            *
073            * @param userId the primary key of the user
074            */
075            public static void addDefaultGroups(long userId)
076                    throws com.liferay.portal.kernel.exception.PortalException {
077                    getService().addDefaultGroups(userId);
078            }
079    
080            /**
081            * Adds the user to the default regular roles, unless the user already has
082            * these regular roles. The default regular roles can be specified in
083            * <code>portal.properties</code> with the key
084            * <code>admin.default.role.names</code>.
085            *
086            * @param userId the primary key of the user
087            */
088            public static void addDefaultRoles(long userId)
089                    throws com.liferay.portal.kernel.exception.PortalException {
090                    getService().addDefaultRoles(userId);
091            }
092    
093            /**
094            * Adds the user to the default user groups, unless the user is already in
095            * these user groups. The default user groups can be specified in
096            * <code>portal.properties</code> with the property
097            * <code>admin.default.user.group.names</code>.
098            *
099            * @param userId the primary key of the user
100            */
101            public static void addDefaultUserGroups(long userId)
102                    throws com.liferay.portal.kernel.exception.PortalException {
103                    getService().addDefaultUserGroups(userId);
104            }
105    
106            public static void addGroupUser(long groupId,
107                    com.liferay.portal.model.User user) {
108                    getService().addGroupUser(groupId, user);
109            }
110    
111            public static void addGroupUser(long groupId, long userId) {
112                    getService().addGroupUser(groupId, userId);
113            }
114    
115            /**
116            * @throws PortalException
117            */
118            public static void addGroupUsers(long groupId,
119                    java.util.List<com.liferay.portal.model.User> Users)
120                    throws com.liferay.portal.kernel.exception.PortalException {
121                    getService().addGroupUsers(groupId, Users);
122            }
123    
124            /**
125            * @throws PortalException
126            */
127            public static void addGroupUsers(long groupId, long[] userIds)
128                    throws com.liferay.portal.kernel.exception.PortalException {
129                    getService().addGroupUsers(groupId, userIds);
130            }
131    
132            public static void addOrganizationUser(long organizationId,
133                    com.liferay.portal.model.User user) {
134                    getService().addOrganizationUser(organizationId, user);
135            }
136    
137            public static void addOrganizationUser(long organizationId, long userId) {
138                    getService().addOrganizationUser(organizationId, userId);
139            }
140    
141            /**
142            * @throws PortalException
143            */
144            public static void addOrganizationUsers(long organizationId,
145                    java.util.List<com.liferay.portal.model.User> Users)
146                    throws com.liferay.portal.kernel.exception.PortalException {
147                    getService().addOrganizationUsers(organizationId, Users);
148            }
149    
150            /**
151            * @throws PortalException
152            */
153            public static void addOrganizationUsers(long organizationId, long[] userIds)
154                    throws com.liferay.portal.kernel.exception.PortalException {
155                    getService().addOrganizationUsers(organizationId, userIds);
156            }
157    
158            /**
159            * Assigns the password policy to the users, removing any other currently
160            * assigned password policies.
161            *
162            * @param passwordPolicyId the primary key of the password policy
163            * @param userIds the primary keys of the users
164            */
165            public static void addPasswordPolicyUsers(long passwordPolicyId,
166                    long[] userIds) {
167                    getService().addPasswordPolicyUsers(passwordPolicyId, userIds);
168            }
169    
170            public static void addRoleUser(long roleId,
171                    com.liferay.portal.model.User user) {
172                    getService().addRoleUser(roleId, user);
173            }
174    
175            public static void addRoleUser(long roleId, long userId) {
176                    getService().addRoleUser(roleId, userId);
177            }
178    
179            /**
180            * @throws PortalException
181            */
182            public static void addRoleUsers(long roleId,
183                    java.util.List<com.liferay.portal.model.User> Users)
184                    throws com.liferay.portal.kernel.exception.PortalException {
185                    getService().addRoleUsers(roleId, Users);
186            }
187    
188            /**
189            * @throws PortalException
190            */
191            public static void addRoleUsers(long roleId, long[] userIds)
192                    throws com.liferay.portal.kernel.exception.PortalException {
193                    getService().addRoleUsers(roleId, userIds);
194            }
195    
196            public static void addTeamUser(long teamId,
197                    com.liferay.portal.model.User user) {
198                    getService().addTeamUser(teamId, user);
199            }
200    
201            public static void addTeamUser(long teamId, long userId) {
202                    getService().addTeamUser(teamId, userId);
203            }
204    
205            /**
206            * @throws PortalException
207            */
208            public static void addTeamUsers(long teamId,
209                    java.util.List<com.liferay.portal.model.User> Users)
210                    throws com.liferay.portal.kernel.exception.PortalException {
211                    getService().addTeamUsers(teamId, Users);
212            }
213    
214            /**
215            * @throws PortalException
216            */
217            public static void addTeamUsers(long teamId, long[] userIds)
218                    throws com.liferay.portal.kernel.exception.PortalException {
219                    getService().addTeamUsers(teamId, userIds);
220            }
221    
222            /**
223            * Adds a user.
224            *
225            * <p>
226            * This method handles the creation and bookkeeping of the user including
227            * its resources, metadata, and internal data structures. It is not
228            * necessary to make subsequent calls to any methods to setup default
229            * groups, resources, etc.
230            * </p>
231            *
232            * @param creatorUserId the primary key of the creator
233            * @param companyId the primary key of the user's company
234            * @param autoPassword whether a password should be automatically generated
235            for the user
236            * @param password1 the user's password
237            * @param password2 the user's password confirmation
238            * @param autoScreenName whether a screen name should be automatically
239            generated for the user
240            * @param screenName the user's screen name
241            * @param emailAddress the user's email address
242            * @param facebookId the user's facebook ID
243            * @param openId the user's OpenID
244            * @param locale the user's locale
245            * @param firstName the user's first name
246            * @param middleName the user's middle name
247            * @param lastName the user's last name
248            * @param prefixId the user's name prefix ID
249            * @param suffixId the user's name suffix ID
250            * @param male whether the user is male
251            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
252            January)
253            * @param birthdayDay the user's birthday day
254            * @param birthdayYear the user's birthday year
255            * @param jobTitle the user's job title
256            * @param groupIds the primary keys of the user's groups
257            * @param organizationIds the primary keys of the user's organizations
258            * @param roleIds the primary keys of the roles this user possesses
259            * @param userGroupIds the primary keys of the user's user groups
260            * @param sendEmail whether to send the user an email notification about
261            their new account
262            * @param serviceContext the service context to be applied (optionally
263            <code>null</code>). Can set the UUID (with the <code>uuid</code>
264            attribute), asset category IDs, asset tag names, and expando
265            bridge attributes for the user.
266            * @return the new user
267            */
268            public static com.liferay.portal.model.User addUser(long creatorUserId,
269                    long companyId, boolean autoPassword, java.lang.String password1,
270                    java.lang.String password2, boolean autoScreenName,
271                    java.lang.String screenName, java.lang.String emailAddress,
272                    long facebookId, java.lang.String openId, java.util.Locale locale,
273                    java.lang.String firstName, java.lang.String middleName,
274                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
275                    int birthdayMonth, int birthdayDay, int birthdayYear,
276                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
277                    long[] roleIds, long[] userGroupIds, boolean sendEmail,
278                    com.liferay.portal.service.ServiceContext serviceContext)
279                    throws com.liferay.portal.kernel.exception.PortalException {
280                    return getService()
281                                       .addUser(creatorUserId, companyId, autoPassword, password1,
282                            password2, autoScreenName, screenName, emailAddress, facebookId,
283                            openId, locale, firstName, middleName, lastName, prefixId,
284                            suffixId, male, birthdayMonth, birthdayDay, birthdayYear, jobTitle,
285                            groupIds, organizationIds, roleIds, userGroupIds, sendEmail,
286                            serviceContext);
287            }
288    
289            /**
290            * Adds the user to the database. Also notifies the appropriate model listeners.
291            *
292            * @param user the user
293            * @return the user that was added
294            */
295            public static com.liferay.portal.model.User addUser(
296                    com.liferay.portal.model.User user) {
297                    return getService().addUser(user);
298            }
299    
300            public static void addUserGroupUser(long userGroupId,
301                    com.liferay.portal.model.User user) {
302                    getService().addUserGroupUser(userGroupId, user);
303            }
304    
305            public static void addUserGroupUser(long userGroupId, long userId) {
306                    getService().addUserGroupUser(userGroupId, userId);
307            }
308    
309            /**
310            * @throws PortalException
311            */
312            public static void addUserGroupUsers(long userGroupId,
313                    java.util.List<com.liferay.portal.model.User> Users)
314                    throws com.liferay.portal.kernel.exception.PortalException {
315                    getService().addUserGroupUsers(userGroupId, Users);
316            }
317    
318            /**
319            * @throws PortalException
320            */
321            public static void addUserGroupUsers(long userGroupId, long[] userIds)
322                    throws com.liferay.portal.kernel.exception.PortalException {
323                    getService().addUserGroupUsers(userGroupId, userIds);
324            }
325    
326            /**
327            * Adds a user with workflow.
328            *
329            * <p>
330            * This method handles the creation and bookkeeping of the user including
331            * its resources, metadata, and internal data structures. It is not
332            * necessary to make subsequent calls to any methods to setup default
333            * groups, resources, etc.
334            * </p>
335            *
336            * @param creatorUserId the primary key of the creator
337            * @param companyId the primary key of the user's company
338            * @param autoPassword whether a password should be automatically generated
339            for the user
340            * @param password1 the user's password
341            * @param password2 the user's password confirmation
342            * @param autoScreenName whether a screen name should be automatically
343            generated for the user
344            * @param screenName the user's screen name
345            * @param emailAddress the user's email address
346            * @param facebookId the user's facebook ID
347            * @param openId the user's OpenID
348            * @param locale the user's locale
349            * @param firstName the user's first name
350            * @param middleName the user's middle name
351            * @param lastName the user's last name
352            * @param prefixId the user's name prefix ID
353            * @param suffixId the user's name suffix ID
354            * @param male whether the user is male
355            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
356            January)
357            * @param birthdayDay the user's birthday day
358            * @param birthdayYear the user's birthday year
359            * @param jobTitle the user's job title
360            * @param groupIds the primary keys of the user's groups
361            * @param organizationIds the primary keys of the user's organizations
362            * @param roleIds the primary keys of the roles this user possesses
363            * @param userGroupIds the primary keys of the user's user groups
364            * @param sendEmail whether to send the user an email notification about
365            their new account
366            * @param serviceContext the service context to be applied (optionally
367            <code>null</code>). Can set the UUID (with the <code>uuid</code>
368            attribute), asset category IDs, asset tag names, and expando
369            bridge attributes for the user.
370            * @return the new user
371            */
372            public static com.liferay.portal.model.User addUserWithWorkflow(
373                    long creatorUserId, long companyId, boolean autoPassword,
374                    java.lang.String password1, java.lang.String password2,
375                    boolean autoScreenName, java.lang.String screenName,
376                    java.lang.String emailAddress, long facebookId,
377                    java.lang.String openId, java.util.Locale locale,
378                    java.lang.String firstName, java.lang.String middleName,
379                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
380                    int birthdayMonth, int birthdayDay, int birthdayYear,
381                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
382                    long[] roleIds, long[] userGroupIds, boolean sendEmail,
383                    com.liferay.portal.service.ServiceContext serviceContext)
384                    throws com.liferay.portal.kernel.exception.PortalException {
385                    return getService()
386                                       .addUserWithWorkflow(creatorUserId, companyId, autoPassword,
387                            password1, password2, autoScreenName, screenName, emailAddress,
388                            facebookId, openId, locale, firstName, middleName, lastName,
389                            prefixId, suffixId, male, birthdayMonth, birthdayDay, birthdayYear,
390                            jobTitle, groupIds, organizationIds, roleIds, userGroupIds,
391                            sendEmail, serviceContext);
392            }
393    
394            /**
395            * Attempts to authenticate the user by their email address and password,
396            * while using the AuthPipeline.
397            *
398            * @param companyId the primary key of the user's company
399            * @param emailAddress the user's email address
400            * @param password the user's password
401            * @param headerMap the header map from the authentication request
402            * @param parameterMap the parameter map from the authentication request
403            * @param resultsMap the map of authentication results (may be nil). After
404            a successful authentication the user's primary key will be placed
405            under the key <code>userId</code>.
406            * @return the authentication status. This can be {@link
407            Authenticator#FAILURE} indicating that the user's credentials are
408            invalid, {@link Authenticator#SUCCESS} indicating a successful
409            login, or {@link Authenticator#DNE} indicating that a user with
410            that login does not exist.
411            * @see AuthPipeline
412            */
413            public static int authenticateByEmailAddress(long companyId,
414                    java.lang.String emailAddress, java.lang.String password,
415                    java.util.Map<java.lang.String, java.lang.String[]> headerMap,
416                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
417                    java.util.Map<java.lang.String, java.lang.Object> resultsMap)
418                    throws com.liferay.portal.kernel.exception.PortalException {
419                    return getService()
420                                       .authenticateByEmailAddress(companyId, emailAddress,
421                            password, headerMap, parameterMap, resultsMap);
422            }
423    
424            /**
425            * Attempts to authenticate the user by their screen name and password,
426            * while using the AuthPipeline.
427            *
428            * @param companyId the primary key of the user's company
429            * @param screenName the user's screen name
430            * @param password the user's password
431            * @param headerMap the header map from the authentication request
432            * @param parameterMap the parameter map from the authentication request
433            * @param resultsMap the map of authentication results (may be nil). After
434            a successful authentication the user's primary key will be placed
435            under the key <code>userId</code>.
436            * @return the authentication status. This can be {@link
437            Authenticator#FAILURE} indicating that the user's credentials are
438            invalid, {@link Authenticator#SUCCESS} indicating a successful
439            login, or {@link Authenticator#DNE} indicating that a user with
440            that login does not exist.
441            * @see AuthPipeline
442            */
443            public static int authenticateByScreenName(long companyId,
444                    java.lang.String screenName, java.lang.String password,
445                    java.util.Map<java.lang.String, java.lang.String[]> headerMap,
446                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
447                    java.util.Map<java.lang.String, java.lang.Object> resultsMap)
448                    throws com.liferay.portal.kernel.exception.PortalException {
449                    return getService()
450                                       .authenticateByScreenName(companyId, screenName, password,
451                            headerMap, parameterMap, resultsMap);
452            }
453    
454            /**
455            * Attempts to authenticate the user by their primary key and password,
456            * while using the AuthPipeline.
457            *
458            * @param companyId the primary key of the user's company
459            * @param userId the user's primary key
460            * @param password the user's password
461            * @param headerMap the header map from the authentication request
462            * @param parameterMap the parameter map from the authentication request
463            * @param resultsMap the map of authentication results (may be nil). After
464            a successful authentication the user's primary key will be placed
465            under the key <code>userId</code>.
466            * @return the authentication status. This can be {@link
467            Authenticator#FAILURE} indicating that the user's credentials are
468            invalid, {@link Authenticator#SUCCESS} indicating a successful
469            login, or {@link Authenticator#DNE} indicating that a user with
470            that login does not exist.
471            * @see AuthPipeline
472            */
473            public static int authenticateByUserId(long companyId, long userId,
474                    java.lang.String password,
475                    java.util.Map<java.lang.String, java.lang.String[]> headerMap,
476                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
477                    java.util.Map<java.lang.String, java.lang.Object> resultsMap)
478                    throws com.liferay.portal.kernel.exception.PortalException {
479                    return getService()
480                                       .authenticateByUserId(companyId, userId, password,
481                            headerMap, parameterMap, resultsMap);
482            }
483    
484            /**
485            * Attempts to authenticate the user using HTTP basic access authentication,
486            * without using the AuthPipeline. Primarily used for authenticating users
487            * of <code>tunnel-web</code>.
488            *
489            * <p>
490            * Authentication type specifies what <code>login</code> contains.The valid
491            * values are:
492            * </p>
493            *
494            * <ul>
495            * <li>
496            * <code>CompanyConstants.AUTH_TYPE_EA</code> - <code>login</code> is the
497            * user's email address
498            * </li>
499            * <li>
500            * <code>CompanyConstants.AUTH_TYPE_SN</code> - <code>login</code> is the
501            * user's screen name
502            * </li>
503            * <li>
504            * <code>CompanyConstants.AUTH_TYPE_ID</code> - <code>login</code> is the
505            * user's primary key
506            * </li>
507            * </ul>
508            *
509            * @param companyId the primary key of the user's company
510            * @param authType the type of authentication to perform
511            * @param login either the user's email address, screen name, or primary
512            key depending on the value of <code>authType</code>
513            * @param password the user's password
514            * @return the user's primary key if authentication is successful;
515            <code>0</code> otherwise
516            */
517            public static long authenticateForBasic(long companyId,
518                    java.lang.String authType, java.lang.String login,
519                    java.lang.String password)
520                    throws com.liferay.portal.kernel.exception.PortalException {
521                    return getService()
522                                       .authenticateForBasic(companyId, authType, login, password);
523            }
524    
525            /**
526            * Attempts to authenticate the user using HTTP digest access
527            * authentication, without using the AuthPipeline. Primarily used for
528            * authenticating users of <code>tunnel-web</code>.
529            *
530            * @param companyId the primary key of the user's company
531            * @param username either the user's email address, screen name, or primary
532            key
533            * @param realm unused
534            * @param nonce the number used once
535            * @param method the request method
536            * @param uri the request URI
537            * @param response the authentication response hash
538            * @return the user's primary key if authentication is successful;
539            <code>0</code> otherwise
540            */
541            public static long authenticateForDigest(long companyId,
542                    java.lang.String username, java.lang.String realm,
543                    java.lang.String nonce, java.lang.String method, java.lang.String uri,
544                    java.lang.String response)
545                    throws com.liferay.portal.kernel.exception.PortalException {
546                    return getService()
547                                       .authenticateForDigest(companyId, username, realm, nonce,
548                            method, uri, response);
549            }
550    
551            /**
552            * Attempts to authenticate the user using JAAS credentials, without using
553            * the AuthPipeline.
554            *
555            * @param userId the primary key of the user
556            * @param encPassword the encrypted password
557            * @return <code>true</code> if authentication is successful;
558            <code>false</code> otherwise
559            */
560            public static boolean authenticateForJAAS(long userId,
561                    java.lang.String encPassword) {
562                    return getService().authenticateForJAAS(userId, encPassword);
563            }
564    
565            /**
566            * Checks if the user is currently locked out based on the password policy,
567            * and performs maintenance on the user's lockout and failed login data.
568            *
569            * @param user the user
570            */
571            public static void checkLockout(com.liferay.portal.model.User user)
572                    throws com.liferay.portal.kernel.exception.PortalException {
573                    getService().checkLockout(user);
574            }
575    
576            /**
577            * Adds a failed login attempt to the user and updates the user's last
578            * failed login date.
579            *
580            * @param user the user
581            */
582            public static void checkLoginFailure(com.liferay.portal.model.User user) {
583                    getService().checkLoginFailure(user);
584            }
585    
586            /**
587            * Adds a failed login attempt to the user with the email address and
588            * updates the user's last failed login date.
589            *
590            * @param companyId the primary key of the user's company
591            * @param emailAddress the user's email address
592            */
593            public static void checkLoginFailureByEmailAddress(long companyId,
594                    java.lang.String emailAddress)
595                    throws com.liferay.portal.kernel.exception.PortalException {
596                    getService().checkLoginFailureByEmailAddress(companyId, emailAddress);
597            }
598    
599            /**
600            * Adds a failed login attempt to the user and updates the user's last
601            * failed login date.
602            *
603            * @param userId the primary key of the user
604            */
605            public static void checkLoginFailureById(long userId)
606                    throws com.liferay.portal.kernel.exception.PortalException {
607                    getService().checkLoginFailureById(userId);
608            }
609    
610            /**
611            * Adds a failed login attempt to the user with the screen name and updates
612            * the user's last failed login date.
613            *
614            * @param companyId the primary key of the user's company
615            * @param screenName the user's screen name
616            */
617            public static void checkLoginFailureByScreenName(long companyId,
618                    java.lang.String screenName)
619                    throws com.liferay.portal.kernel.exception.PortalException {
620                    getService().checkLoginFailureByScreenName(companyId, screenName);
621            }
622    
623            /**
624            * Checks if the user's password is expired based on the password policy,
625            * and performs maintenance on the user's grace login and password reset
626            * data.
627            *
628            * @param user the user
629            */
630            public static void checkPasswordExpired(com.liferay.portal.model.User user)
631                    throws com.liferay.portal.kernel.exception.PortalException {
632                    getService().checkPasswordExpired(user);
633            }
634    
635            public static void clearGroupUsers(long groupId) {
636                    getService().clearGroupUsers(groupId);
637            }
638    
639            public static void clearOrganizationUsers(long organizationId) {
640                    getService().clearOrganizationUsers(organizationId);
641            }
642    
643            public static void clearRoleUsers(long roleId) {
644                    getService().clearRoleUsers(roleId);
645            }
646    
647            public static void clearTeamUsers(long teamId) {
648                    getService().clearTeamUsers(teamId);
649            }
650    
651            public static void clearUserGroupUsers(long userGroupId) {
652                    getService().clearUserGroupUsers(userGroupId);
653            }
654    
655            /**
656            * Completes the user's registration by generating a password and sending
657            * the confirmation email.
658            *
659            * @param user the user
660            * @param serviceContext the service context to be applied. You can specify
661            an unencrypted custom password for the user via attribute
662            <code>passwordUnencrypted</code>. You automatically generate a
663            password for the user by setting attribute
664            <code>autoPassword</code> to <code>true</code>. You can send a
665            confirmation email to the user by setting attribute
666            <code>sendEmail</code> to <code>true</code>.
667            */
668            public static void completeUserRegistration(
669                    com.liferay.portal.model.User user,
670                    com.liferay.portal.service.ServiceContext serviceContext)
671                    throws com.liferay.portal.kernel.exception.PortalException {
672                    getService().completeUserRegistration(user, serviceContext);
673            }
674    
675            /**
676            * Creates a new user with the primary key. Does not add the user to the database.
677            *
678            * @param userId the primary key for the new user
679            * @return the new user
680            */
681            public static com.liferay.portal.model.User createUser(long userId) {
682                    return getService().createUser(userId);
683            }
684    
685            /**
686            * Decrypts the user's primary key and password from their encrypted forms.
687            * Used for decrypting a user's credentials from the values stored in an
688            * automatic login cookie.
689            *
690            * @param companyId the primary key of the user's company
691            * @param name the encrypted primary key of the user
692            * @param password the encrypted password of the user
693            * @return the user's primary key and password
694            */
695            public static com.liferay.portal.kernel.util.KeyValuePair decryptUserId(
696                    long companyId, java.lang.String name, java.lang.String password)
697                    throws com.liferay.portal.kernel.exception.PortalException {
698                    return getService().decryptUserId(companyId, name, password);
699            }
700    
701            public static void deleteGroupUser(long groupId,
702                    com.liferay.portal.model.User user) {
703                    getService().deleteGroupUser(groupId, user);
704            }
705    
706            public static void deleteGroupUser(long groupId, long userId) {
707                    getService().deleteGroupUser(groupId, userId);
708            }
709    
710            public static void deleteGroupUsers(long groupId,
711                    java.util.List<com.liferay.portal.model.User> Users) {
712                    getService().deleteGroupUsers(groupId, Users);
713            }
714    
715            public static void deleteGroupUsers(long groupId, long[] userIds) {
716                    getService().deleteGroupUsers(groupId, userIds);
717            }
718    
719            public static void deleteOrganizationUser(long organizationId,
720                    com.liferay.portal.model.User user) {
721                    getService().deleteOrganizationUser(organizationId, user);
722            }
723    
724            public static void deleteOrganizationUser(long organizationId, long userId) {
725                    getService().deleteOrganizationUser(organizationId, userId);
726            }
727    
728            public static void deleteOrganizationUsers(long organizationId,
729                    java.util.List<com.liferay.portal.model.User> Users) {
730                    getService().deleteOrganizationUsers(organizationId, Users);
731            }
732    
733            public static void deleteOrganizationUsers(long organizationId,
734                    long[] userIds) {
735                    getService().deleteOrganizationUsers(organizationId, userIds);
736            }
737    
738            /**
739            * @throws PortalException
740            */
741            public static com.liferay.portal.model.PersistedModel deletePersistedModel(
742                    com.liferay.portal.model.PersistedModel persistedModel)
743                    throws com.liferay.portal.kernel.exception.PortalException {
744                    return getService().deletePersistedModel(persistedModel);
745            }
746    
747            /**
748            * Deletes the user's portrait image.
749            *
750            * @param userId the primary key of the user
751            */
752            public static void deletePortrait(long userId)
753                    throws com.liferay.portal.kernel.exception.PortalException {
754                    getService().deletePortrait(userId);
755            }
756    
757            /**
758            * @throws PortalException
759            */
760            public static void deleteRoleUser(long roleId,
761                    com.liferay.portal.model.User user)
762                    throws com.liferay.portal.kernel.exception.PortalException {
763                    getService().deleteRoleUser(roleId, user);
764            }
765    
766            /**
767            * @throws PortalException
768            */
769            public static void deleteRoleUser(long roleId, long userId)
770                    throws com.liferay.portal.kernel.exception.PortalException {
771                    getService().deleteRoleUser(roleId, userId);
772            }
773    
774            public static void deleteRoleUsers(long roleId,
775                    java.util.List<com.liferay.portal.model.User> Users) {
776                    getService().deleteRoleUsers(roleId, Users);
777            }
778    
779            public static void deleteRoleUsers(long roleId, long[] userIds) {
780                    getService().deleteRoleUsers(roleId, userIds);
781            }
782    
783            public static void deleteTeamUser(long teamId,
784                    com.liferay.portal.model.User user) {
785                    getService().deleteTeamUser(teamId, user);
786            }
787    
788            public static void deleteTeamUser(long teamId, long userId) {
789                    getService().deleteTeamUser(teamId, userId);
790            }
791    
792            public static void deleteTeamUsers(long teamId,
793                    java.util.List<com.liferay.portal.model.User> Users) {
794                    getService().deleteTeamUsers(teamId, Users);
795            }
796    
797            public static void deleteTeamUsers(long teamId, long[] userIds) {
798                    getService().deleteTeamUsers(teamId, userIds);
799            }
800    
801            /**
802            * Deletes the user from the database. Also notifies the appropriate model listeners.
803            *
804            * @param user the user
805            * @return the user that was removed
806            * @throws PortalException
807            */
808            public static com.liferay.portal.model.User deleteUser(
809                    com.liferay.portal.model.User user)
810                    throws com.liferay.portal.kernel.exception.PortalException {
811                    return getService().deleteUser(user);
812            }
813    
814            /**
815            * Deletes the user with the primary key from the database. Also notifies the appropriate model listeners.
816            *
817            * @param userId the primary key of the user
818            * @return the user that was removed
819            * @throws PortalException if a user with the primary key could not be found
820            */
821            public static com.liferay.portal.model.User deleteUser(long userId)
822                    throws com.liferay.portal.kernel.exception.PortalException {
823                    return getService().deleteUser(userId);
824            }
825    
826            /**
827            * @throws PortalException
828            */
829            public static void deleteUserGroupUser(long userGroupId,
830                    com.liferay.portal.model.User user)
831                    throws com.liferay.portal.kernel.exception.PortalException {
832                    getService().deleteUserGroupUser(userGroupId, user);
833            }
834    
835            /**
836            * @throws PortalException
837            */
838            public static void deleteUserGroupUser(long userGroupId, long userId)
839                    throws com.liferay.portal.kernel.exception.PortalException {
840                    getService().deleteUserGroupUser(userGroupId, userId);
841            }
842    
843            public static void deleteUserGroupUsers(long userGroupId,
844                    java.util.List<com.liferay.portal.model.User> Users) {
845                    getService().deleteUserGroupUsers(userGroupId, Users);
846            }
847    
848            public static void deleteUserGroupUsers(long userGroupId, long[] userIds) {
849                    getService().deleteUserGroupUsers(userGroupId, userIds);
850            }
851    
852            public static com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
853                    return getService().dynamicQuery();
854            }
855    
856            /**
857            * Performs a dynamic query on the database and returns the matching rows.
858            *
859            * @param dynamicQuery the dynamic query
860            * @return the matching rows
861            */
862            public static <T> java.util.List<T> dynamicQuery(
863                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
864                    return getService().dynamicQuery(dynamicQuery);
865            }
866    
867            /**
868            * Performs a dynamic query on the database and returns a range of the matching rows.
869            *
870            * <p>
871            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
872            * </p>
873            *
874            * @param dynamicQuery the dynamic query
875            * @param start the lower bound of the range of model instances
876            * @param end the upper bound of the range of model instances (not inclusive)
877            * @return the range of matching rows
878            */
879            public static <T> java.util.List<T> dynamicQuery(
880                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
881                    int end) {
882                    return getService().dynamicQuery(dynamicQuery, start, end);
883            }
884    
885            /**
886            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
887            *
888            * <p>
889            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
890            * </p>
891            *
892            * @param dynamicQuery the dynamic query
893            * @param start the lower bound of the range of model instances
894            * @param end the upper bound of the range of model instances (not inclusive)
895            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
896            * @return the ordered range of matching rows
897            */
898            public static <T> java.util.List<T> dynamicQuery(
899                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
900                    int end,
901                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
902                    return getService()
903                                       .dynamicQuery(dynamicQuery, start, end, orderByComparator);
904            }
905    
906            /**
907            * Returns the number of rows matching the dynamic query.
908            *
909            * @param dynamicQuery the dynamic query
910            * @return the number of rows matching the dynamic query
911            */
912            public static long dynamicQueryCount(
913                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
914                    return getService().dynamicQueryCount(dynamicQuery);
915            }
916    
917            /**
918            * Returns the number of rows matching the dynamic query.
919            *
920            * @param dynamicQuery the dynamic query
921            * @param projection the projection to apply to the query
922            * @return the number of rows matching the dynamic query
923            */
924            public static long dynamicQueryCount(
925                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
926                    com.liferay.portal.kernel.dao.orm.Projection projection) {
927                    return getService().dynamicQueryCount(dynamicQuery, projection);
928            }
929    
930            /**
931            * Encrypts the primary key of the user. Used when encrypting the user's
932            * credentials for storage in an automatic login cookie.
933            *
934            * @param name the primary key of the user
935            * @return the user's encrypted primary key
936            */
937            public static java.lang.String encryptUserId(java.lang.String name)
938                    throws com.liferay.portal.kernel.exception.PortalException {
939                    return getService().encryptUserId(name);
940            }
941    
942            public static com.liferay.portal.model.User fetchUser(long userId) {
943                    return getService().fetchUser(userId);
944            }
945    
946            /**
947            * Returns the user with the contact ID.
948            *
949            * @param contactId the user's contact ID
950            * @return the user with the contact ID, or <code>null</code> if a user with
951            the contact ID could not be found
952            */
953            public static com.liferay.portal.model.User fetchUserByContactId(
954                    long contactId) {
955                    return getService().fetchUserByContactId(contactId);
956            }
957    
958            /**
959            * Returns the user with the email address.
960            *
961            * @param companyId the primary key of the user's company
962            * @param emailAddress the user's email address
963            * @return the user with the email address, or <code>null</code> if a user
964            with the email address could not be found
965            */
966            public static com.liferay.portal.model.User fetchUserByEmailAddress(
967                    long companyId, java.lang.String emailAddress) {
968                    return getService().fetchUserByEmailAddress(companyId, emailAddress);
969            }
970    
971            /**
972            * Returns the user with the Facebook ID.
973            *
974            * @param companyId the primary key of the user's company
975            * @param facebookId the user's Facebook ID
976            * @return the user with the Facebook ID, or <code>null</code> if a user
977            with the Facebook ID could not be found
978            */
979            public static com.liferay.portal.model.User fetchUserByFacebookId(
980                    long companyId, long facebookId) {
981                    return getService().fetchUserByFacebookId(companyId, facebookId);
982            }
983    
984            /**
985            * Returns the user with the primary key.
986            *
987            * @param userId the primary key of the user
988            * @return the user with the primary key, or <code>null</code> if a user
989            with the primary key could not be found
990            */
991            public static com.liferay.portal.model.User fetchUserById(long userId) {
992                    return getService().fetchUserById(userId);
993            }
994    
995            /**
996            * Returns the user with the OpenID.
997            *
998            * @param companyId the primary key of the user's company
999            * @param openId the user's OpenID
1000            * @return the user with the OpenID, or <code>null</code> if a user with the
1001            OpenID could not be found
1002            */
1003            public static com.liferay.portal.model.User fetchUserByOpenId(
1004                    long companyId, java.lang.String openId) {
1005                    return getService().fetchUserByOpenId(companyId, openId);
1006            }
1007    
1008            /**
1009            * Returns the user with the portrait ID.
1010            *
1011            * @param portraitId the user's portrait ID
1012            * @return the user with the portrait ID, or <code>null</code> if a user
1013            with the portrait ID could not be found
1014            */
1015            public static com.liferay.portal.model.User fetchUserByPortraitId(
1016                    long portraitId) {
1017                    return getService().fetchUserByPortraitId(portraitId);
1018            }
1019    
1020            /**
1021            * Returns the user with the screen name.
1022            *
1023            * @param companyId the primary key of the user's company
1024            * @param screenName the user's screen name
1025            * @return the user with the screen name, or <code>null</code> if a user
1026            with the screen name could not be found
1027            */
1028            public static com.liferay.portal.model.User fetchUserByScreenName(
1029                    long companyId, java.lang.String screenName) {
1030                    return getService().fetchUserByScreenName(companyId, screenName);
1031            }
1032    
1033            /**
1034            * Returns the user with the matching UUID and company.
1035            *
1036            * @param uuid the user's UUID
1037            * @param companyId the primary key of the company
1038            * @return the matching user, or <code>null</code> if a matching user could not be found
1039            */
1040            public static com.liferay.portal.model.User fetchUserByUuidAndCompanyId(
1041                    java.lang.String uuid, long companyId) {
1042                    return getService().fetchUserByUuidAndCompanyId(uuid, companyId);
1043            }
1044    
1045            public static com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
1046                    return getService().getActionableDynamicQuery();
1047            }
1048    
1049            /**
1050            * Returns a range of all the users belonging to the company.
1051            *
1052            * <p>
1053            * Useful when paginating results. Returns a maximum of <code>end -
1054            * start</code> instances. <code>start</code> and <code>end</code> are not
1055            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1056            * refers to the first result in the set. Setting both <code>start</code>
1057            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1058            * result set.
1059            * </p>
1060            *
1061            * @param companyId the primary key of the company
1062            * @param start the lower bound of the range of users
1063            * @param end the upper bound of the range of users (not inclusive)
1064            * @return the range of users belonging to the company
1065            */
1066            public static java.util.List<com.liferay.portal.model.User> getCompanyUsers(
1067                    long companyId, int start, int end) {
1068                    return getService().getCompanyUsers(companyId, start, end);
1069            }
1070    
1071            /**
1072            * Returns the number of users belonging to the company.
1073            *
1074            * @param companyId the primary key of the company
1075            * @return the number of users belonging to the company
1076            */
1077            public static int getCompanyUsersCount(long companyId) {
1078                    return getService().getCompanyUsersCount(companyId);
1079            }
1080    
1081            /**
1082            * Returns the default user for the company.
1083            *
1084            * @param companyId the primary key of the company
1085            * @return the default user for the company
1086            */
1087            public static com.liferay.portal.model.User getDefaultUser(long companyId)
1088                    throws com.liferay.portal.kernel.exception.PortalException {
1089                    return getService().getDefaultUser(companyId);
1090            }
1091    
1092            /**
1093            * Returns the primary key of the default user for the company.
1094            *
1095            * @param companyId the primary key of the company
1096            * @return the primary key of the default user for the company
1097            */
1098            public static long getDefaultUserId(long companyId)
1099                    throws com.liferay.portal.kernel.exception.PortalException {
1100                    return getService().getDefaultUserId(companyId);
1101            }
1102    
1103            public static com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
1104                    com.liferay.portlet.exportimport.lar.PortletDataContext portletDataContext) {
1105                    return getService().getExportActionableDynamicQuery(portletDataContext);
1106            }
1107    
1108            /**
1109            * Returns the groupIds of the groups associated with the user.
1110            *
1111            * @param userId the userId of the user
1112            * @return long[] the groupIds of groups associated with the user
1113            */
1114            public static long[] getGroupPrimaryKeys(long userId) {
1115                    return getService().getGroupPrimaryKeys(userId);
1116            }
1117    
1118            /**
1119            * Returns the primary keys of all the users belonging to the group.
1120            *
1121            * @param groupId the primary key of the group
1122            * @return the primary keys of the users belonging to the group
1123            */
1124            public static long[] getGroupUserIds(long groupId) {
1125                    return getService().getGroupUserIds(groupId);
1126            }
1127    
1128            public static java.util.List<com.liferay.portal.model.User> getGroupUsers(
1129                    long groupId) {
1130                    return getService().getGroupUsers(groupId);
1131            }
1132    
1133            public static java.util.List<com.liferay.portal.model.User> getGroupUsers(
1134                    long groupId, int start, int end) {
1135                    return getService().getGroupUsers(groupId, start, end);
1136            }
1137    
1138            public static java.util.List<com.liferay.portal.model.User> getGroupUsers(
1139                    long groupId, int start, int end,
1140                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
1141                    return getService().getGroupUsers(groupId, start, end, orderByComparator);
1142            }
1143    
1144            public static int getGroupUsersCount(long groupId) {
1145                    return getService().getGroupUsersCount(groupId);
1146            }
1147    
1148            /**
1149            * Returns the number of users with the status belonging to the group.
1150            *
1151            * @param groupId the primary key of the group
1152            * @param status the workflow status
1153            * @return the number of users with the status belonging to the group
1154            */
1155            public static int getGroupUsersCount(long groupId, int status)
1156                    throws com.liferay.portal.kernel.exception.PortalException {
1157                    return getService().getGroupUsersCount(groupId, status);
1158            }
1159    
1160            public static com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() {
1161                    return getService().getIndexableActionableDynamicQuery();
1162            }
1163    
1164            public static java.util.List<com.liferay.portal.model.User> getInheritedRoleUsers(
1165                    long roleId, int start, int end,
1166                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc)
1167                    throws com.liferay.portal.kernel.exception.PortalException {
1168                    return getService().getInheritedRoleUsers(roleId, start, end, obc);
1169            }
1170    
1171            /**
1172            * Returns all the users who have not had any announcements of the type
1173            * delivered, excluding the default user.
1174            *
1175            * @param type the type of announcement
1176            * @return the users who have not had any annoucements of the type delivered
1177            */
1178            public static java.util.List<com.liferay.portal.model.User> getNoAnnouncementsDeliveries(
1179                    java.lang.String type) {
1180                    return getService().getNoAnnouncementsDeliveries(type);
1181            }
1182    
1183            /**
1184            * Returns all the users who do not have any contacts.
1185            *
1186            * @return the users who do not have any contacts
1187            */
1188            public static java.util.List<com.liferay.portal.model.User> getNoContacts() {
1189                    return getService().getNoContacts();
1190            }
1191    
1192            /**
1193            * Returns all the users who do not belong to any groups, excluding the
1194            * default user.
1195            *
1196            * @return the users who do not belong to any groups
1197            */
1198            public static java.util.List<com.liferay.portal.model.User> getNoGroups() {
1199                    return getService().getNoGroups();
1200            }
1201    
1202            /**
1203            * Returns the OSGi service identifier.
1204            *
1205            * @return the OSGi service identifier
1206            */
1207            public static java.lang.String getOSGiServiceIdentifier() {
1208                    return getService().getOSGiServiceIdentifier();
1209            }
1210    
1211            /**
1212            * Returns the organizationIds of the organizations associated with the user.
1213            *
1214            * @param userId the userId of the user
1215            * @return long[] the organizationIds of organizations associated with the user
1216            */
1217            public static long[] getOrganizationPrimaryKeys(long userId) {
1218                    return getService().getOrganizationPrimaryKeys(userId);
1219            }
1220    
1221            /**
1222            * Returns the primary keys of all the users belonging to the organization.
1223            *
1224            * @param organizationId the primary key of the organization
1225            * @return the primary keys of the users belonging to the organization
1226            */
1227            public static long[] getOrganizationUserIds(long organizationId) {
1228                    return getService().getOrganizationUserIds(organizationId);
1229            }
1230    
1231            public static java.util.List<com.liferay.portal.model.User> getOrganizationUsers(
1232                    long organizationId) {
1233                    return getService().getOrganizationUsers(organizationId);
1234            }
1235    
1236            public static java.util.List<com.liferay.portal.model.User> getOrganizationUsers(
1237                    long organizationId, int start, int end) {
1238                    return getService().getOrganizationUsers(organizationId, start, end);
1239            }
1240    
1241            public static java.util.List<com.liferay.portal.model.User> getOrganizationUsers(
1242                    long organizationId, int start, int end,
1243                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
1244                    return getService()
1245                                       .getOrganizationUsers(organizationId, start, end,
1246                            orderByComparator);
1247            }
1248    
1249            public static int getOrganizationUsersCount(long organizationId) {
1250                    return getService().getOrganizationUsersCount(organizationId);
1251            }
1252    
1253            /**
1254            * Returns the number of users with the status belonging to the
1255            * organization.
1256            *
1257            * @param organizationId the primary key of the organization
1258            * @param status the workflow status
1259            * @return the number of users with the status belonging to the organization
1260            */
1261            public static int getOrganizationUsersCount(long organizationId, int status)
1262                    throws com.liferay.portal.kernel.exception.PortalException {
1263                    return getService().getOrganizationUsersCount(organizationId, status);
1264            }
1265    
1266            public static com.liferay.portal.model.PersistedModel getPersistedModel(
1267                    java.io.Serializable primaryKeyObj)
1268                    throws com.liferay.portal.kernel.exception.PortalException {
1269                    return getService().getPersistedModel(primaryKeyObj);
1270            }
1271    
1272            /**
1273            * Returns the roleIds of the roles associated with the user.
1274            *
1275            * @param userId the userId of the user
1276            * @return long[] the roleIds of roles associated with the user
1277            */
1278            public static long[] getRolePrimaryKeys(long userId) {
1279                    return getService().getRolePrimaryKeys(userId);
1280            }
1281    
1282            /**
1283            * Returns the primary keys of all the users belonging to the role.
1284            *
1285            * @param roleId the primary key of the role
1286            * @return the primary keys of the users belonging to the role
1287            */
1288            public static long[] getRoleUserIds(long roleId) {
1289                    return getService().getRoleUserIds(roleId);
1290            }
1291    
1292            public static java.util.List<com.liferay.portal.model.User> getRoleUsers(
1293                    long roleId) {
1294                    return getService().getRoleUsers(roleId);
1295            }
1296    
1297            public static java.util.List<com.liferay.portal.model.User> getRoleUsers(
1298                    long roleId, int start, int end) {
1299                    return getService().getRoleUsers(roleId, start, end);
1300            }
1301    
1302            public static java.util.List<com.liferay.portal.model.User> getRoleUsers(
1303                    long roleId, int start, int end,
1304                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
1305                    return getService().getRoleUsers(roleId, start, end, orderByComparator);
1306            }
1307    
1308            public static int getRoleUsersCount(long roleId) {
1309                    return getService().getRoleUsersCount(roleId);
1310            }
1311    
1312            /**
1313            * Returns the number of users with the status belonging to the role.
1314            *
1315            * @param roleId the primary key of the role
1316            * @param status the workflow status
1317            * @return the number of users with the status belonging to the role
1318            */
1319            public static int getRoleUsersCount(long roleId, int status)
1320                    throws com.liferay.portal.kernel.exception.PortalException {
1321                    return getService().getRoleUsersCount(roleId, status);
1322            }
1323    
1324            public static java.util.List<com.liferay.portal.model.User> getSocialUsers(
1325                    long userId, int socialRelationType,
1326                    java.lang.String socialRelationTypeComparator, int start, int end,
1327                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc)
1328                    throws com.liferay.portal.kernel.exception.PortalException {
1329                    return getService()
1330                                       .getSocialUsers(userId, socialRelationType,
1331                            socialRelationTypeComparator, start, end, obc);
1332            }
1333    
1334            /**
1335            * Returns an ordered range of all the users with a social relation of the
1336            * type with the user.
1337            *
1338            * <p>
1339            * Useful when paginating results. Returns a maximum of <code>end -
1340            * start</code> instances. <code>start</code> and <code>end</code> are not
1341            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1342            * refers to the first result in the set. Setting both <code>start</code>
1343            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1344            * result set.
1345            * </p>
1346            *
1347            * @param userId the primary key of the user
1348            * @param socialRelationType the type of social relation. The possible
1349            types can be found in {@link SocialRelationConstants}.
1350            * @param start the lower bound of the range of users
1351            * @param end the upper bound of the range of users (not inclusive)
1352            * @param obc the comparator to order the users by (optionally
1353            <code>null</code>)
1354            * @return the ordered range of users with a social relation of the type
1355            with the user
1356            * @deprecated As of 7.0.0, replaced by {@link #getSocialUsers(long, int,
1357            String, int, int, OrderByComparator)}
1358            */
1359            @Deprecated
1360            public static java.util.List<com.liferay.portal.model.User> getSocialUsers(
1361                    long userId, int socialRelationType, int start, int end,
1362                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc)
1363                    throws com.liferay.portal.kernel.exception.PortalException {
1364                    return getService()
1365                                       .getSocialUsers(userId, socialRelationType, start, end, obc);
1366            }
1367    
1368            /**
1369            * Returns an ordered range of all the users with a social relation with the
1370            * user.
1371            *
1372            * <p>
1373            * Useful when paginating results. Returns a maximum of <code>end -
1374            * start</code> instances. <code>start</code> and <code>end</code> are not
1375            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1376            * refers to the first result in the set. Setting both <code>start</code>
1377            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1378            * result set.
1379            * </p>
1380            *
1381            * @param userId the primary key of the user
1382            * @param start the lower bound of the range of users
1383            * @param end the upper bound of the range of users (not inclusive)
1384            * @param obc the comparator to order the users by (optionally
1385            <code>null</code>)
1386            * @return the ordered range of users with a social relation with the
1387            user
1388            * @deprecated As of 7.0.0, replaced by {@link #getSocialUsers(long, int,
1389            String, int, int, OrderByComparator)}
1390            */
1391            @Deprecated
1392            public static java.util.List<com.liferay.portal.model.User> getSocialUsers(
1393                    long userId, int start, int end,
1394                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc)
1395                    throws com.liferay.portal.kernel.exception.PortalException {
1396                    return getService().getSocialUsers(userId, start, end, obc);
1397            }
1398    
1399            /**
1400            * Returns an ordered range of all the users with a mutual social relation
1401            * of the type with both of the given users.
1402            *
1403            * <p>
1404            * Useful when paginating results. Returns a maximum of <code>end -
1405            * start</code> instances. <code>start</code> and <code>end</code> are not
1406            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1407            * refers to the first result in the set. Setting both <code>start</code>
1408            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1409            * result set.
1410            * </p>
1411            *
1412            * @param userId1 the primary key of the first user
1413            * @param userId2 the primary key of the second user
1414            * @param socialRelationType the type of social relation. The possible
1415            types can be found in {@link SocialRelationConstants}.
1416            * @param start the lower bound of the range of users
1417            * @param end the upper bound of the range of users (not inclusive)
1418            * @param obc the comparator to order the users by (optionally
1419            <code>null</code>)
1420            * @return the ordered range of users with a mutual social relation of the
1421            type with the user
1422            */
1423            public static java.util.List<com.liferay.portal.model.User> getSocialUsers(
1424                    long userId1, long userId2, int socialRelationType, int start, int end,
1425                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc)
1426                    throws com.liferay.portal.kernel.exception.PortalException {
1427                    return getService()
1428                                       .getSocialUsers(userId1, userId2, socialRelationType, start,
1429                            end, obc);
1430            }
1431    
1432            /**
1433            * Returns an ordered range of all the users with a mutual social relation
1434            * with both of the given users.
1435            *
1436            * <p>
1437            * Useful when paginating results. Returns a maximum of <code>end -
1438            * start</code> instances. <code>start</code> and <code>end</code> are not
1439            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1440            * refers to the first result in the set. Setting both <code>start</code>
1441            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1442            * result set.
1443            * </p>
1444            *
1445            * @param userId1 the primary key of the first user
1446            * @param userId2 the primary key of the second user
1447            * @param start the lower bound of the range of users
1448            * @param end the upper bound of the range of users (not inclusive)
1449            * @param obc the comparator to order the users by (optionally
1450            <code>null</code>)
1451            * @return the ordered range of users with a mutual social relation with the
1452            user
1453            */
1454            public static java.util.List<com.liferay.portal.model.User> getSocialUsers(
1455                    long userId1, long userId2, int start, int end,
1456                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc)
1457                    throws com.liferay.portal.kernel.exception.PortalException {
1458                    return getService().getSocialUsers(userId1, userId2, start, end, obc);
1459            }
1460    
1461            /**
1462            * Returns the number of users with a social relation with the user.
1463            *
1464            * @param userId the primary key of the user
1465            * @return the number of users with a social relation with the user
1466            * @deprecated As of 7.0.0, replaced by {@link #getSocialUsersCount(long,
1467            int, String)}
1468            */
1469            @Deprecated
1470            public static int getSocialUsersCount(long userId)
1471                    throws com.liferay.portal.kernel.exception.PortalException {
1472                    return getService().getSocialUsersCount(userId);
1473            }
1474    
1475            /**
1476            * Returns the number of users with a social relation of the type with the
1477            * user.
1478            *
1479            * @param userId the primary key of the user
1480            * @param socialRelationType the type of social relation. The possible
1481            types can be found in {@link SocialRelationConstants}.
1482            * @return the number of users with a social relation of the type with
1483            the user
1484            * @deprecated As of 7.0.0, replaced by {@link #getSocialUsersCount(long,
1485            int, String)}
1486            */
1487            @Deprecated
1488            public static int getSocialUsersCount(long userId, int socialRelationType)
1489                    throws com.liferay.portal.kernel.exception.PortalException {
1490                    return getService().getSocialUsersCount(userId, socialRelationType);
1491            }
1492    
1493            /**
1494            * Returns the number of users with a social relation with the user.
1495            *
1496            * @param userId the primary key of the user
1497            * @param socialRelationType the type of social relation. The possible
1498            types can be found in {@link SocialRelationConstants}.
1499            * @return the number of users with a social relation with the user
1500            */
1501            public static int getSocialUsersCount(long userId, int socialRelationType,
1502                    java.lang.String socialRelationTypeComparator)
1503                    throws com.liferay.portal.kernel.exception.PortalException {
1504                    return getService()
1505                                       .getSocialUsersCount(userId, socialRelationType,
1506                            socialRelationTypeComparator);
1507            }
1508    
1509            /**
1510            * Returns the number of users with a mutual social relation with both of
1511            * the given users.
1512            *
1513            * @param userId1 the primary key of the first user
1514            * @param userId2 the primary key of the second user
1515            * @return the number of users with a mutual social relation with the user
1516            */
1517            public static int getSocialUsersCount(long userId1, long userId2)
1518                    throws com.liferay.portal.kernel.exception.PortalException {
1519                    return getService().getSocialUsersCount(userId1, userId2);
1520            }
1521    
1522            /**
1523            * Returns the number of users with a mutual social relation of the type
1524            * with both of the given users.
1525            *
1526            * @param userId1 the primary key of the first user
1527            * @param userId2 the primary key of the second user
1528            * @param socialRelationType the type of social relation. The possible
1529            types can be found in {@link SocialRelationConstants}.
1530            * @return the number of users with a mutual social relation of the type
1531            with the user
1532            */
1533            public static int getSocialUsersCount(long userId1, long userId2,
1534                    int socialRelationType)
1535                    throws com.liferay.portal.kernel.exception.PortalException {
1536                    return getService()
1537                                       .getSocialUsersCount(userId1, userId2, socialRelationType);
1538            }
1539    
1540            /**
1541            * Returns the teamIds of the teams associated with the user.
1542            *
1543            * @param userId the userId of the user
1544            * @return long[] the teamIds of teams associated with the user
1545            */
1546            public static long[] getTeamPrimaryKeys(long userId) {
1547                    return getService().getTeamPrimaryKeys(userId);
1548            }
1549    
1550            public static java.util.List<com.liferay.portal.model.User> getTeamUsers(
1551                    long teamId) {
1552                    return getService().getTeamUsers(teamId);
1553            }
1554    
1555            public static java.util.List<com.liferay.portal.model.User> getTeamUsers(
1556                    long teamId, int start, int end) {
1557                    return getService().getTeamUsers(teamId, start, end);
1558            }
1559    
1560            public static java.util.List<com.liferay.portal.model.User> getTeamUsers(
1561                    long teamId, int start, int end,
1562                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
1563                    return getService().getTeamUsers(teamId, start, end, orderByComparator);
1564            }
1565    
1566            public static int getTeamUsersCount(long teamId) {
1567                    return getService().getTeamUsersCount(teamId);
1568            }
1569    
1570            /**
1571            * Returns the user with the primary key.
1572            *
1573            * @param userId the primary key of the user
1574            * @return the user
1575            * @throws PortalException if a user with the primary key could not be found
1576            */
1577            public static com.liferay.portal.model.User getUser(long userId)
1578                    throws com.liferay.portal.kernel.exception.PortalException {
1579                    return getService().getUser(userId);
1580            }
1581    
1582            /**
1583            * Returns the user with the contact ID.
1584            *
1585            * @param contactId the user's contact ID
1586            * @return the user with the contact ID
1587            */
1588            public static com.liferay.portal.model.User getUserByContactId(
1589                    long contactId)
1590                    throws com.liferay.portal.kernel.exception.PortalException {
1591                    return getService().getUserByContactId(contactId);
1592            }
1593    
1594            /**
1595            * Returns the user with the email address.
1596            *
1597            * @param companyId the primary key of the user's company
1598            * @param emailAddress the user's email address
1599            * @return the user with the email address
1600            */
1601            public static com.liferay.portal.model.User getUserByEmailAddress(
1602                    long companyId, java.lang.String emailAddress)
1603                    throws com.liferay.portal.kernel.exception.PortalException {
1604                    return getService().getUserByEmailAddress(companyId, emailAddress);
1605            }
1606    
1607            /**
1608            * Returns the user with the Facebook ID.
1609            *
1610            * @param companyId the primary key of the user's company
1611            * @param facebookId the user's Facebook ID
1612            * @return the user with the Facebook ID
1613            */
1614            public static com.liferay.portal.model.User getUserByFacebookId(
1615                    long companyId, long facebookId)
1616                    throws com.liferay.portal.kernel.exception.PortalException {
1617                    return getService().getUserByFacebookId(companyId, facebookId);
1618            }
1619    
1620            /**
1621            * Returns the user with the primary key from the company.
1622            *
1623            * @param companyId the primary key of the user's company
1624            * @param userId the primary key of the user
1625            * @return the user with the primary key
1626            */
1627            public static com.liferay.portal.model.User getUserById(long companyId,
1628                    long userId) throws com.liferay.portal.kernel.exception.PortalException {
1629                    return getService().getUserById(companyId, userId);
1630            }
1631    
1632            /**
1633            * Returns the user with the primary key.
1634            *
1635            * @param userId the primary key of the user
1636            * @return the user with the primary key
1637            */
1638            public static com.liferay.portal.model.User getUserById(long userId)
1639                    throws com.liferay.portal.kernel.exception.PortalException {
1640                    return getService().getUserById(userId);
1641            }
1642    
1643            /**
1644            * Returns the user with the OpenID.
1645            *
1646            * @param companyId the primary key of the user's company
1647            * @param openId the user's OpenID
1648            * @return the user with the OpenID
1649            */
1650            public static com.liferay.portal.model.User getUserByOpenId(
1651                    long companyId, java.lang.String openId)
1652                    throws com.liferay.portal.kernel.exception.PortalException {
1653                    return getService().getUserByOpenId(companyId, openId);
1654            }
1655    
1656            /**
1657            * Returns the user with the portrait ID.
1658            *
1659            * @param portraitId the user's portrait ID
1660            * @return the user with the portrait ID
1661            */
1662            public static com.liferay.portal.model.User getUserByPortraitId(
1663                    long portraitId)
1664                    throws com.liferay.portal.kernel.exception.PortalException {
1665                    return getService().getUserByPortraitId(portraitId);
1666            }
1667    
1668            /**
1669            * Returns the user with the screen name.
1670            *
1671            * @param companyId the primary key of the user's company
1672            * @param screenName the user's screen name
1673            * @return the user with the screen name
1674            */
1675            public static com.liferay.portal.model.User getUserByScreenName(
1676                    long companyId, java.lang.String screenName)
1677                    throws com.liferay.portal.kernel.exception.PortalException {
1678                    return getService().getUserByScreenName(companyId, screenName);
1679            }
1680    
1681            /**
1682            * Returns the user with the matching UUID and company.
1683            *
1684            * @param uuid the user's UUID
1685            * @param companyId the primary key of the company
1686            * @return the matching user
1687            * @throws PortalException if a matching user could not be found
1688            */
1689            public static com.liferay.portal.model.User getUserByUuidAndCompanyId(
1690                    java.lang.String uuid, long companyId)
1691                    throws com.liferay.portal.kernel.exception.PortalException {
1692                    return getService().getUserByUuidAndCompanyId(uuid, companyId);
1693            }
1694    
1695            /**
1696            * Returns the userGroupIds of the user groups associated with the user.
1697            *
1698            * @param userId the userId of the user
1699            * @return long[] the userGroupIds of user groups associated with the user
1700            */
1701            public static long[] getUserGroupPrimaryKeys(long userId) {
1702                    return getService().getUserGroupPrimaryKeys(userId);
1703            }
1704    
1705            public static java.util.List<com.liferay.portal.model.User> getUserGroupUsers(
1706                    long userGroupId) {
1707                    return getService().getUserGroupUsers(userGroupId);
1708            }
1709    
1710            public static java.util.List<com.liferay.portal.model.User> getUserGroupUsers(
1711                    long userGroupId, int start, int end) {
1712                    return getService().getUserGroupUsers(userGroupId, start, end);
1713            }
1714    
1715            public static java.util.List<com.liferay.portal.model.User> getUserGroupUsers(
1716                    long userGroupId, int start, int end,
1717                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
1718                    return getService()
1719                                       .getUserGroupUsers(userGroupId, start, end, orderByComparator);
1720            }
1721    
1722            public static int getUserGroupUsersCount(long userGroupId) {
1723                    return getService().getUserGroupUsersCount(userGroupId);
1724            }
1725    
1726            /**
1727            * Returns the number of users with the status belonging to the user group.
1728            *
1729            * @param userGroupId the primary key of the user group
1730            * @param status the workflow status
1731            * @return the number of users with the status belonging to the user group
1732            */
1733            public static int getUserGroupUsersCount(long userGroupId, int status)
1734                    throws com.liferay.portal.kernel.exception.PortalException {
1735                    return getService().getUserGroupUsersCount(userGroupId, status);
1736            }
1737    
1738            /**
1739            * Returns the primary key of the user with the email address.
1740            *
1741            * @param companyId the primary key of the user's company
1742            * @param emailAddress the user's email address
1743            * @return the primary key of the user with the email address
1744            */
1745            public static long getUserIdByEmailAddress(long companyId,
1746                    java.lang.String emailAddress)
1747                    throws com.liferay.portal.kernel.exception.PortalException {
1748                    return getService().getUserIdByEmailAddress(companyId, emailAddress);
1749            }
1750    
1751            /**
1752            * Returns the primary key of the user with the screen name.
1753            *
1754            * @param companyId the primary key of the user's company
1755            * @param screenName the user's screen name
1756            * @return the primary key of the user with the screen name
1757            */
1758            public static long getUserIdByScreenName(long companyId,
1759                    java.lang.String screenName)
1760                    throws com.liferay.portal.kernel.exception.PortalException {
1761                    return getService().getUserIdByScreenName(companyId, screenName);
1762            }
1763    
1764            /**
1765            * Returns a range of all the users.
1766            *
1767            * <p>
1768            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.UserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1769            * </p>
1770            *
1771            * @param start the lower bound of the range of users
1772            * @param end the upper bound of the range of users (not inclusive)
1773            * @return the range of users
1774            */
1775            public static java.util.List<com.liferay.portal.model.User> getUsers(
1776                    int start, int end) {
1777                    return getService().getUsers(start, end);
1778            }
1779    
1780            /**
1781            * Returns the number of users.
1782            *
1783            * @return the number of users
1784            */
1785            public static int getUsersCount() {
1786                    return getService().getUsersCount();
1787            }
1788    
1789            public static boolean hasGroupUser(long groupId, long userId) {
1790                    return getService().hasGroupUser(groupId, userId);
1791            }
1792    
1793            public static boolean hasGroupUsers(long groupId) {
1794                    return getService().hasGroupUsers(groupId);
1795            }
1796    
1797            public static boolean hasOrganizationUser(long organizationId, long userId) {
1798                    return getService().hasOrganizationUser(organizationId, userId);
1799            }
1800    
1801            public static boolean hasOrganizationUsers(long organizationId) {
1802                    return getService().hasOrganizationUsers(organizationId);
1803            }
1804    
1805            /**
1806            * Returns <code>true</code> if the password policy has been assigned to the
1807            * user.
1808            *
1809            * @param passwordPolicyId the primary key of the password policy
1810            * @param userId the primary key of the user
1811            * @return <code>true</code> if the password policy is assigned to the user;
1812            <code>false</code> otherwise
1813            */
1814            public static boolean hasPasswordPolicyUser(long passwordPolicyId,
1815                    long userId) {
1816                    return getService().hasPasswordPolicyUser(passwordPolicyId, userId);
1817            }
1818    
1819            /**
1820            * Returns <code>true</code> if the user has the role with the name,
1821            * optionally through inheritance.
1822            *
1823            * @param companyId the primary key of the role's company
1824            * @param name the name of the role (must be a regular role, not an
1825            organization, site or provider role)
1826            * @param userId the primary key of the user
1827            * @param inherited whether to include roles inherited from organizations,
1828            sites, etc.
1829            * @return <code>true</code> if the user has the role; <code>false</code>
1830            otherwise
1831            */
1832            public static boolean hasRoleUser(long companyId, java.lang.String name,
1833                    long userId, boolean inherited)
1834                    throws com.liferay.portal.kernel.exception.PortalException {
1835                    return getService().hasRoleUser(companyId, name, userId, inherited);
1836            }
1837    
1838            public static boolean hasRoleUser(long roleId, long userId) {
1839                    return getService().hasRoleUser(roleId, userId);
1840            }
1841    
1842            public static boolean hasRoleUsers(long roleId) {
1843                    return getService().hasRoleUsers(roleId);
1844            }
1845    
1846            public static boolean hasTeamUser(long teamId, long userId) {
1847                    return getService().hasTeamUser(teamId, userId);
1848            }
1849    
1850            public static boolean hasTeamUsers(long teamId) {
1851                    return getService().hasTeamUsers(teamId);
1852            }
1853    
1854            public static boolean hasUserGroupUser(long userGroupId, long userId) {
1855                    return getService().hasUserGroupUser(userGroupId, userId);
1856            }
1857    
1858            public static boolean hasUserGroupUsers(long userGroupId) {
1859                    return getService().hasUserGroupUsers(userGroupId);
1860            }
1861    
1862            /**
1863            * Returns <code>true</code> if the user's password is expired.
1864            *
1865            * @param user the user
1866            * @return <code>true</code> if the user's password is expired;
1867            <code>false</code> otherwise
1868            */
1869            public static boolean isPasswordExpired(com.liferay.portal.model.User user)
1870                    throws com.liferay.portal.kernel.exception.PortalException {
1871                    return getService().isPasswordExpired(user);
1872            }
1873    
1874            /**
1875            * Returns <code>true</code> if the password policy is configured to warn
1876            * the user that his password is expiring and the remaining time until
1877            * expiration is equal or less than the configured warning time.
1878            *
1879            * @param user the user
1880            * @return <code>true</code> if the user's password is expiring soon;
1881            <code>false</code> otherwise
1882            */
1883            public static boolean isPasswordExpiringSoon(
1884                    com.liferay.portal.model.User user)
1885                    throws com.liferay.portal.kernel.exception.PortalException {
1886                    return getService().isPasswordExpiringSoon(user);
1887            }
1888    
1889            /**
1890            * Returns the default user for the company.
1891            *
1892            * @param companyId the primary key of the company
1893            * @return the default user for the company
1894            */
1895            public static com.liferay.portal.model.User loadGetDefaultUser(
1896                    long companyId)
1897                    throws com.liferay.portal.kernel.exception.PortalException {
1898                    return getService().loadGetDefaultUser(companyId);
1899            }
1900    
1901            /**
1902            * Returns an ordered range of all the users with the status, and whose
1903            * first name, middle name, last name, screen name, and email address match
1904            * the keywords specified for them, without using the indexer. It is
1905            * preferable to use the indexed version {@link #search(long, String,
1906            * String, String, String, String, int, LinkedHashMap, boolean, int, int,
1907            * Sort)} instead of this method wherever possible for performance reasons.
1908            *
1909            * <p>
1910            * Useful when paginating results. Returns a maximum of <code>end -
1911            * start</code> instances. <code>start</code> and <code>end</code> are not
1912            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1913            * refers to the first result in the set. Setting both <code>start</code>
1914            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1915            * result set.
1916            * </p>
1917            *
1918            * @param companyId the primary key of the user's company
1919            * @param firstName the first name keywords (space separated)
1920            * @param middleName the middle name keywords
1921            * @param lastName the last name keywords
1922            * @param screenName the screen name keywords
1923            * @param emailAddress the email address keywords
1924            * @param status the workflow status
1925            * @param params the finder parameters (optionally <code>null</code>). For
1926            more information see {@link
1927            com.liferay.portal.service.persistence.UserFinder}.
1928            * @param andSearch whether every field must match its keywords, or just
1929            one field. For example, &quot;users with the first name 'bob' and
1930            last name 'smith'&quot; vs &quot;users with the first name 'bob'
1931            or the last name 'smith'&quot;.
1932            * @param start the lower bound of the range of users
1933            * @param end the upper bound of the range of users (not inclusive)
1934            * @param obc the comparator to order the users by (optionally
1935            <code>null</code>)
1936            * @return the matching users
1937            * @see com.liferay.portal.service.persistence.UserFinder
1938            */
1939            public static java.util.List<com.liferay.portal.model.User> search(
1940                    long companyId, java.lang.String firstName,
1941                    java.lang.String middleName, java.lang.String lastName,
1942                    java.lang.String screenName, java.lang.String emailAddress, int status,
1943                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1944                    boolean andSearch, int start, int end,
1945                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) {
1946                    return getService()
1947                                       .search(companyId, firstName, middleName, lastName,
1948                            screenName, emailAddress, status, params, andSearch, start, end, obc);
1949            }
1950    
1951            /**
1952            * Returns an ordered range of all the users with the status, and whose
1953            * first name, middle name, last name, screen name, and email address match
1954            * the keywords specified for them, using the indexer. It is preferable to
1955            * use this method instead of the non-indexed version whenever possible for
1956            * performance reasons.
1957            *
1958            * <p>
1959            * Useful when paginating results. Returns a maximum of <code>end -
1960            * start</code> instances. <code>start</code> and <code>end</code> are not
1961            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1962            * refers to the first result in the set. Setting both <code>start</code>
1963            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1964            * result set.
1965            * </p>
1966            *
1967            * @param companyId the primary key of the user's company
1968            * @param firstName the first name keywords (space separated)
1969            * @param middleName the middle name keywords
1970            * @param lastName the last name keywords
1971            * @param screenName the screen name keywords
1972            * @param emailAddress the email address keywords
1973            * @param status the workflow status
1974            * @param params the indexer parameters (optionally <code>null</code>). For
1975            more information see {@link
1976            com.liferay.portlet.usersadmin.util.UserIndexer}.
1977            * @param andSearch whether every field must match its keywords, or just
1978            one field. For example, &quot;users with the first name 'bob' and
1979            last name 'smith'&quot; vs &quot;users with the first name 'bob'
1980            or the last name 'smith'&quot;.
1981            * @param start the lower bound of the range of users
1982            * @param end the upper bound of the range of users (not inclusive)
1983            * @param sort the field and direction to sort by (optionally
1984            <code>null</code>)
1985            * @return the matching users
1986            * @see com.liferay.portlet.usersadmin.util.UserIndexer
1987            */
1988            public static com.liferay.portal.kernel.search.Hits search(long companyId,
1989                    java.lang.String firstName, java.lang.String middleName,
1990                    java.lang.String lastName, java.lang.String screenName,
1991                    java.lang.String emailAddress, int status,
1992                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1993                    boolean andSearch, int start, int end,
1994                    com.liferay.portal.kernel.search.Sort sort) {
1995                    return getService()
1996                                       .search(companyId, firstName, middleName, lastName,
1997                            screenName, emailAddress, status, params, andSearch, start, end,
1998                            sort);
1999            }
2000    
2001            public static com.liferay.portal.kernel.search.Hits search(long companyId,
2002                    java.lang.String firstName, java.lang.String middleName,
2003                    java.lang.String lastName, java.lang.String screenName,
2004                    java.lang.String emailAddress, int status,
2005                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2006                    boolean andSearch, int start, int end,
2007                    com.liferay.portal.kernel.search.Sort[] sorts) {
2008                    return getService()
2009                                       .search(companyId, firstName, middleName, lastName,
2010                            screenName, emailAddress, status, params, andSearch, start, end,
2011                            sorts);
2012            }
2013    
2014            /**
2015            * Returns an ordered range of all the users who match the keywords and
2016            * status, without using the indexer. It is preferable to use the indexed
2017            * version {@link #search(long, String, int, LinkedHashMap, int, int, Sort)}
2018            * instead of this method wherever possible for performance reasons.
2019            *
2020            * <p>
2021            * Useful when paginating results. Returns a maximum of <code>end -
2022            * start</code> instances. <code>start</code> and <code>end</code> are not
2023            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2024            * refers to the first result in the set. Setting both <code>start</code>
2025            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2026            * result set.
2027            * </p>
2028            *
2029            * @param companyId the primary key of the user's company
2030            * @param keywords the keywords (space separated), which may occur in the
2031            user's first name, middle name, last name, screen name, or email
2032            address
2033            * @param status the workflow status
2034            * @param params the finder parameters (optionally <code>null</code>). For
2035            more information see {@link
2036            com.liferay.portal.service.persistence.UserFinder}.
2037            * @param start the lower bound of the range of users
2038            * @param end the upper bound of the range of users (not inclusive)
2039            * @param obc the comparator to order the users by (optionally
2040            <code>null</code>)
2041            * @return the matching users
2042            * @see com.liferay.portal.service.persistence.UserFinder
2043            */
2044            public static java.util.List<com.liferay.portal.model.User> search(
2045                    long companyId, java.lang.String keywords, int status,
2046                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2047                    int start, int end,
2048                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) {
2049                    return getService()
2050                                       .search(companyId, keywords, status, params, start, end, obc);
2051            }
2052    
2053            /**
2054            * Returns an ordered range of all the users who match the keywords and
2055            * status, using the indexer. It is preferable to use this method instead of
2056            * the non-indexed version whenever possible for performance reasons.
2057            *
2058            * <p>
2059            * Useful when paginating results. Returns a maximum of <code>end -
2060            * start</code> instances. <code>start</code> and <code>end</code> are not
2061            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2062            * refers to the first result in the set. Setting both <code>start</code>
2063            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2064            * result set.
2065            * </p>
2066            *
2067            * @param companyId the primary key of the user's company
2068            * @param keywords the keywords (space separated), which may occur in the
2069            user's first name, middle name, last name, screen name, or email
2070            address
2071            * @param status the workflow status
2072            * @param params the indexer parameters (optionally <code>null</code>). For
2073            more information see {@link
2074            com.liferay.portlet.usersadmin.util.UserIndexer}.
2075            * @param start the lower bound of the range of users
2076            * @param end the upper bound of the range of users (not inclusive)
2077            * @param sort the field and direction to sort by (optionally
2078            <code>null</code>)
2079            * @return the matching users
2080            * @see com.liferay.portlet.usersadmin.util.UserIndexer
2081            */
2082            public static com.liferay.portal.kernel.search.Hits search(long companyId,
2083                    java.lang.String keywords, int status,
2084                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2085                    int start, int end, com.liferay.portal.kernel.search.Sort sort) {
2086                    return getService()
2087                                       .search(companyId, keywords, status, params, start, end, sort);
2088            }
2089    
2090            public static com.liferay.portal.kernel.search.Hits search(long companyId,
2091                    java.lang.String keywords, int status,
2092                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2093                    int start, int end, com.liferay.portal.kernel.search.Sort[] sorts) {
2094                    return getService()
2095                                       .search(companyId, keywords, status, params, start, end,
2096                            sorts);
2097            }
2098    
2099            /**
2100            * Returns the number of users with the status, and whose first name, middle
2101            * name, last name, screen name, and email address match the keywords
2102            * specified for them.
2103            *
2104            * @param companyId the primary key of the user's company
2105            * @param firstName the first name keywords (space separated)
2106            * @param middleName the middle name keywords
2107            * @param lastName the last name keywords
2108            * @param screenName the screen name keywords
2109            * @param emailAddress the email address keywords
2110            * @param status the workflow status
2111            * @param params the finder parameters (optionally <code>null</code>). For
2112            more information see {@link
2113            com.liferay.portal.service.persistence.UserFinder}.
2114            * @param andSearch whether every field must match its keywords, or just
2115            one field. For example, &quot;users with the first name 'bob' and
2116            last name 'smith'&quot; vs &quot;users with the first name 'bob'
2117            or the last name 'smith'&quot;.
2118            * @return the number of matching users
2119            */
2120            public static int searchCount(long companyId, java.lang.String firstName,
2121                    java.lang.String middleName, java.lang.String lastName,
2122                    java.lang.String screenName, java.lang.String emailAddress, int status,
2123                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2124                    boolean andSearch) {
2125                    return getService()
2126                                       .searchCount(companyId, firstName, middleName, lastName,
2127                            screenName, emailAddress, status, params, andSearch);
2128            }
2129    
2130            /**
2131            * Returns the number of users who match the keywords and status.
2132            *
2133            * @param companyId the primary key of the user's company
2134            * @param keywords the keywords (space separated), which may occur in the
2135            user's first name, middle name, last name, screen name, or email
2136            address
2137            * @param status the workflow status
2138            * @param params the finder parameters (optionally <code>null</code>). For
2139            more information see {@link
2140            com.liferay.portal.service.persistence.UserFinder}.
2141            * @return the number matching users
2142            */
2143            public static int searchCount(long companyId, java.lang.String keywords,
2144                    int status,
2145                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2146                    return getService().searchCount(companyId, keywords, status, params);
2147            }
2148    
2149            public static java.util.Map<java.lang.Long, java.lang.Integer> searchCounts(
2150                    long companyId, int status, long[] groupIds) {
2151                    return getService().searchCounts(companyId, status, groupIds);
2152            }
2153    
2154            public static java.util.List<com.liferay.portal.model.User> searchSocial(
2155                    long companyId, long[] groupIds, java.lang.String keywords, int start,
2156                    int end) {
2157                    return getService()
2158                                       .searchSocial(companyId, groupIds, keywords, start, end);
2159            }
2160    
2161            public static java.util.List<com.liferay.portal.model.User> searchSocial(
2162                    long[] groupIds, long userId, int[] socialRelationTypes,
2163                    java.lang.String keywords, int start, int end)
2164                    throws com.liferay.portal.kernel.exception.PortalException {
2165                    return getService()
2166                                       .searchSocial(groupIds, userId, socialRelationTypes,
2167                            keywords, start, end);
2168            }
2169    
2170            public static java.util.List<com.liferay.portal.model.User> searchSocial(
2171                    long userId, int[] socialRelationTypes, java.lang.String keywords,
2172                    int start, int end)
2173                    throws com.liferay.portal.kernel.exception.PortalException {
2174                    return getService()
2175                                       .searchSocial(userId, socialRelationTypes, keywords, start,
2176                            end);
2177            }
2178    
2179            public static com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2180                    long companyId, java.lang.String firstName,
2181                    java.lang.String middleName, java.lang.String lastName,
2182                    java.lang.String screenName, java.lang.String emailAddress, int status,
2183                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2184                    boolean andSearch, int start, int end,
2185                    com.liferay.portal.kernel.search.Sort sort)
2186                    throws com.liferay.portal.kernel.exception.PortalException {
2187                    return getService()
2188                                       .searchUsers(companyId, firstName, middleName, lastName,
2189                            screenName, emailAddress, status, params, andSearch, start, end,
2190                            sort);
2191            }
2192    
2193            public static com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2194                    long companyId, java.lang.String firstName,
2195                    java.lang.String middleName, java.lang.String lastName,
2196                    java.lang.String screenName, java.lang.String emailAddress, int status,
2197                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2198                    boolean andSearch, int start, int end,
2199                    com.liferay.portal.kernel.search.Sort[] sorts)
2200                    throws com.liferay.portal.kernel.exception.PortalException {
2201                    return getService()
2202                                       .searchUsers(companyId, firstName, middleName, lastName,
2203                            screenName, emailAddress, status, params, andSearch, start, end,
2204                            sorts);
2205            }
2206    
2207            public static com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2208                    long companyId, java.lang.String keywords, int status,
2209                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2210                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
2211                    throws com.liferay.portal.kernel.exception.PortalException {
2212                    return getService()
2213                                       .searchUsers(companyId, keywords, status, params, start,
2214                            end, sort);
2215            }
2216    
2217            public static com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2218                    long companyId, java.lang.String keywords, int status,
2219                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2220                    int start, int end, com.liferay.portal.kernel.search.Sort[] sorts)
2221                    throws com.liferay.portal.kernel.exception.PortalException {
2222                    return getService()
2223                                       .searchUsers(companyId, keywords, status, params, start,
2224                            end, sorts);
2225            }
2226    
2227            /**
2228            * Sends an email address verification to the user.
2229            *
2230            * @param user the verification email recipient
2231            * @param emailAddress the recipient's email address
2232            * @param serviceContext the service context to be applied. Must set the
2233            portal URL, main path, primary key of the layout, remote address,
2234            remote host, and agent for the user.
2235            */
2236            public static void sendEmailAddressVerification(
2237                    com.liferay.portal.model.User user, java.lang.String emailAddress,
2238                    com.liferay.portal.service.ServiceContext serviceContext)
2239                    throws com.liferay.portal.kernel.exception.PortalException {
2240                    getService()
2241                            .sendEmailAddressVerification(user, emailAddress, serviceContext);
2242            }
2243    
2244            /**
2245            * Sends the password email to the user with the email address. The content
2246            * of this email can be specified in <code>portal.properties</code> with the
2247            * <code>admin.email.password</code> keys.
2248            *
2249            * @param companyId the primary key of the user's company
2250            * @param emailAddress the user's email address
2251            * @param fromName the name of the individual that the email should be from
2252            * @param fromAddress the address of the individual that the email should be
2253            from
2254            * @param subject the email subject. If <code>null</code>, the subject
2255            specified in <code>portal.properties</code> will be used.
2256            * @param body the email body. If <code>null</code>, the body specified in
2257            <code>portal.properties</code> will be used.
2258            * @param serviceContext the service context to be applied
2259            */
2260            public static boolean sendPassword(long companyId,
2261                    java.lang.String emailAddress, java.lang.String fromName,
2262                    java.lang.String fromAddress, java.lang.String subject,
2263                    java.lang.String body,
2264                    com.liferay.portal.service.ServiceContext serviceContext)
2265                    throws com.liferay.portal.kernel.exception.PortalException {
2266                    return getService()
2267                                       .sendPassword(companyId, emailAddress, fromName,
2268                            fromAddress, subject, body, serviceContext);
2269            }
2270    
2271            /**
2272            * Sends a password notification email to the user matching the email
2273            * address. The portal's settings determine whether a password is sent
2274            * explicitly or whether a link for resetting the user's password is sent.
2275            * The method sends the email asynchronously and returns before the email is
2276            * sent.
2277            *
2278            * <p>
2279            * The content of the notification email is specified with the
2280            * <code>admin.email.password</code> portal property keys. They can be
2281            * overridden via a <code>portal-ext.properties</code> file or modified
2282            * through the Portal Settings UI.
2283            * </p>
2284            *
2285            * @param companyId the primary key of the user's company
2286            * @param emailAddress the user's email address
2287            * @return <code>true</code> if the notification email includes a new
2288            password; <code>false</code> if the notification email only
2289            contains a reset link
2290            */
2291            public static boolean sendPasswordByEmailAddress(long companyId,
2292                    java.lang.String emailAddress)
2293                    throws com.liferay.portal.kernel.exception.PortalException {
2294                    return getService().sendPasswordByEmailAddress(companyId, emailAddress);
2295            }
2296    
2297            /**
2298            * Sends a password notification email to the user matching the screen name.
2299            * The portal's settings determine whether a password is sent explicitly or
2300            * whether a link for resetting the user's password is sent. The method
2301            * sends the email asynchronously and returns before the email is sent.
2302            *
2303            * <p>
2304            * The content of the notification email is specified with the
2305            * <code>admin.email.password</code> portal property keys. They can be
2306            * overridden via a <code>portal-ext.properties</code> file or modified
2307            * through the Portal Settings UI.
2308            * </p>
2309            *
2310            * @param companyId the primary key of the user's company
2311            * @param screenName the user's screen name
2312            * @return <code>true</code> if the notification email includes a new
2313            password; <code>false</code> if the notification email only
2314            contains a reset link
2315            */
2316            public static boolean sendPasswordByScreenName(long companyId,
2317                    java.lang.String screenName)
2318                    throws com.liferay.portal.kernel.exception.PortalException {
2319                    return getService().sendPasswordByScreenName(companyId, screenName);
2320            }
2321    
2322            /**
2323            * Sends a password notification email to the user matching the ID. The
2324            * portal's settings determine whether a password is sent explicitly or
2325            * whether a link for resetting the user's password is sent. The method
2326            * sends the email asynchronously and returns before the email is sent.
2327            *
2328            * <p>
2329            * The content of the notification email is specified with the
2330            * <code>admin.email.password</code> portal property keys. They can be
2331            * overridden via a <code>portal-ext.properties</code> file or modified
2332            * through the Portal Settings UI.
2333            * </p>
2334            *
2335            * @param userId the user's primary key
2336            * @return <code>true</code> if the notification email includes a new
2337            password; <code>false</code> if the notification email only
2338            contains a reset link
2339            */
2340            public static boolean sendPasswordByUserId(long userId)
2341                    throws com.liferay.portal.kernel.exception.PortalException {
2342                    return getService().sendPasswordByUserId(userId);
2343            }
2344    
2345            public static void setGroupUsers(long groupId, long[] userIds) {
2346                    getService().setGroupUsers(groupId, userIds);
2347            }
2348    
2349            public static void setOrganizationUsers(long organizationId, long[] userIds) {
2350                    getService().setOrganizationUsers(organizationId, userIds);
2351            }
2352    
2353            /**
2354            * @throws PortalException
2355            */
2356            public static void setRoleUsers(long roleId, long[] userIds)
2357                    throws com.liferay.portal.kernel.exception.PortalException {
2358                    getService().setRoleUsers(roleId, userIds);
2359            }
2360    
2361            public static void setTeamUsers(long teamId, long[] userIds) {
2362                    getService().setTeamUsers(teamId, userIds);
2363            }
2364    
2365            /**
2366            * @throws PortalException
2367            */
2368            public static void setUserGroupUsers(long userGroupId, long[] userIds)
2369                    throws com.liferay.portal.kernel.exception.PortalException {
2370                    getService().setUserGroupUsers(userGroupId, userIds);
2371            }
2372    
2373            /**
2374            * Removes the users from the teams of a group.
2375            *
2376            * @param groupId the primary key of the group
2377            * @param userIds the primary keys of the users
2378            */
2379            public static void unsetGroupTeamsUsers(long groupId, long[] userIds)
2380                    throws com.liferay.portal.kernel.exception.PortalException {
2381                    getService().unsetGroupTeamsUsers(groupId, userIds);
2382            }
2383    
2384            /**
2385            * Removes the users from the group.
2386            *
2387            * @param groupId the primary key of the group
2388            * @param userIds the primary keys of the users
2389            * @param serviceContext the service context to be applied (optionally
2390            <code>null</code>)
2391            */
2392            public static void unsetGroupUsers(long groupId, long[] userIds,
2393                    com.liferay.portal.service.ServiceContext serviceContext)
2394                    throws com.liferay.portal.kernel.exception.PortalException {
2395                    getService().unsetGroupUsers(groupId, userIds, serviceContext);
2396            }
2397    
2398            /**
2399            * Removes the users from the organization.
2400            *
2401            * @param organizationId the primary key of the organization
2402            * @param userIds the primary keys of the users
2403            */
2404            public static void unsetOrganizationUsers(long organizationId,
2405                    long[] userIds)
2406                    throws com.liferay.portal.kernel.exception.PortalException {
2407                    getService().unsetOrganizationUsers(organizationId, userIds);
2408            }
2409    
2410            /**
2411            * Removes the users from the password policy.
2412            *
2413            * @param passwordPolicyId the primary key of the password policy
2414            * @param userIds the primary keys of the users
2415            */
2416            public static void unsetPasswordPolicyUsers(long passwordPolicyId,
2417                    long[] userIds) {
2418                    getService().unsetPasswordPolicyUsers(passwordPolicyId, userIds);
2419            }
2420    
2421            /**
2422            * Removes the users from the role.
2423            *
2424            * @param roleId the primary key of the role
2425            * @param userIds the primary keys of the users
2426            */
2427            public static void unsetRoleUsers(long roleId, long[] userIds)
2428                    throws com.liferay.portal.kernel.exception.PortalException {
2429                    getService().unsetRoleUsers(roleId, userIds);
2430            }
2431    
2432            /**
2433            * Removes the users from the role.
2434            *
2435            * @param roleId the primary key of the role
2436            * @param users the users
2437            */
2438            public static void unsetRoleUsers(long roleId,
2439                    java.util.List<com.liferay.portal.model.User> users)
2440                    throws com.liferay.portal.kernel.exception.PortalException {
2441                    getService().unsetRoleUsers(roleId, users);
2442            }
2443    
2444            /**
2445            * Removes the users from the team.
2446            *
2447            * @param teamId the primary key of the team
2448            * @param userIds the primary keys of the users
2449            */
2450            public static void unsetTeamUsers(long teamId, long[] userIds)
2451                    throws com.liferay.portal.kernel.exception.PortalException {
2452                    getService().unsetTeamUsers(teamId, userIds);
2453            }
2454    
2455            /**
2456            * Removes the users from the user group.
2457            *
2458            * @param userGroupId the primary key of the user group
2459            * @param userIds the primary keys of the users
2460            */
2461            public static void unsetUserGroupUsers(long userGroupId, long[] userIds)
2462                    throws com.liferay.portal.kernel.exception.PortalException {
2463                    getService().unsetUserGroupUsers(userGroupId, userIds);
2464            }
2465    
2466            /**
2467            * Updates whether the user has agreed to the terms of use.
2468            *
2469            * @param userId the primary key of the user
2470            * @param agreedToTermsOfUse whether the user has agreet to the terms of
2471            use
2472            * @return the user
2473            */
2474            public static com.liferay.portal.model.User updateAgreedToTermsOfUse(
2475                    long userId, boolean agreedToTermsOfUse)
2476                    throws com.liferay.portal.kernel.exception.PortalException {
2477                    return getService().updateAgreedToTermsOfUse(userId, agreedToTermsOfUse);
2478            }
2479    
2480            /**
2481            * Updates the user's asset with the new asset categories and tag names,
2482            * removing and adding asset categories and tag names as necessary.
2483            *
2484            * @param userId the primary key of the user
2485            * @param user ID the primary key of the user
2486            * @param assetCategoryIds the primary key's of the new asset categories
2487            * @param assetTagNames the new asset tag names
2488            */
2489            public static void updateAsset(long userId,
2490                    com.liferay.portal.model.User user, long[] assetCategoryIds,
2491                    java.lang.String[] assetTagNames)
2492                    throws com.liferay.portal.kernel.exception.PortalException {
2493                    getService().updateAsset(userId, user, assetCategoryIds, assetTagNames);
2494            }
2495    
2496            /**
2497            * Updates the user's creation date.
2498            *
2499            * @param userId the primary key of the user
2500            * @param createDate the new creation date
2501            * @return the user
2502            */
2503            public static com.liferay.portal.model.User updateCreateDate(long userId,
2504                    java.util.Date createDate)
2505                    throws com.liferay.portal.kernel.exception.PortalException {
2506                    return getService().updateCreateDate(userId, createDate);
2507            }
2508    
2509            /**
2510            * Updates the user's email address.
2511            *
2512            * @param userId the primary key of the user
2513            * @param password the user's password
2514            * @param emailAddress1 the user's new email address
2515            * @param emailAddress2 the user's new email address confirmation
2516            * @return the user
2517            */
2518            public static com.liferay.portal.model.User updateEmailAddress(
2519                    long userId, java.lang.String password, java.lang.String emailAddress1,
2520                    java.lang.String emailAddress2)
2521                    throws com.liferay.portal.kernel.exception.PortalException {
2522                    return getService()
2523                                       .updateEmailAddress(userId, password, emailAddress1,
2524                            emailAddress2);
2525            }
2526    
2527            /**
2528            * Updates the user's email address or sends verification email.
2529            *
2530            * @param userId the primary key of the user
2531            * @param password the user's password
2532            * @param emailAddress1 the user's new email address
2533            * @param emailAddress2 the user's new email address confirmation
2534            * @param serviceContext the service context to be applied. Must set the
2535            portal URL, main path, primary key of the layout, remote address,
2536            remote host, and agent for the user.
2537            * @return the user
2538            */
2539            public static com.liferay.portal.model.User updateEmailAddress(
2540                    long userId, java.lang.String password, java.lang.String emailAddress1,
2541                    java.lang.String emailAddress2,
2542                    com.liferay.portal.service.ServiceContext serviceContext)
2543                    throws com.liferay.portal.kernel.exception.PortalException {
2544                    return getService()
2545                                       .updateEmailAddress(userId, password, emailAddress1,
2546                            emailAddress2, serviceContext);
2547            }
2548    
2549            /**
2550            * Updates whether the user has verified email address.
2551            *
2552            * @param userId the primary key of the user
2553            * @param emailAddressVerified whether the user has verified email address
2554            * @return the user
2555            */
2556            public static com.liferay.portal.model.User updateEmailAddressVerified(
2557                    long userId, boolean emailAddressVerified)
2558                    throws com.liferay.portal.kernel.exception.PortalException {
2559                    return getService()
2560                                       .updateEmailAddressVerified(userId, emailAddressVerified);
2561            }
2562    
2563            /**
2564            * Updates the user's Facebook ID.
2565            *
2566            * @param userId the primary key of the user
2567            * @param facebookId the user's new Facebook ID
2568            * @return the user
2569            */
2570            public static com.liferay.portal.model.User updateFacebookId(long userId,
2571                    long facebookId)
2572                    throws com.liferay.portal.kernel.exception.PortalException {
2573                    return getService().updateFacebookId(userId, facebookId);
2574            }
2575    
2576            /**
2577            * Sets the groups the user is in, removing and adding groups as necessary.
2578            *
2579            * @param userId the primary key of the user
2580            * @param newGroupIds the primary keys of the groups
2581            * @param serviceContext the service context to be applied (optionally
2582            <code>null</code>)
2583            */
2584            public static void updateGroups(long userId, long[] newGroupIds,
2585                    com.liferay.portal.service.ServiceContext serviceContext)
2586                    throws com.liferay.portal.kernel.exception.PortalException {
2587                    getService().updateGroups(userId, newGroupIds, serviceContext);
2588            }
2589    
2590            /**
2591            * Updates a user account that was automatically created when a guest user
2592            * participated in an action (e.g. posting a comment) and only provided his
2593            * name and email address.
2594            *
2595            * @param creatorUserId the primary key of the creator
2596            * @param companyId the primary key of the user's company
2597            * @param autoPassword whether a password should be automatically generated
2598            for the user
2599            * @param password1 the user's password
2600            * @param password2 the user's password confirmation
2601            * @param autoScreenName whether a screen name should be automatically
2602            generated for the user
2603            * @param screenName the user's screen name
2604            * @param emailAddress the user's email address
2605            * @param facebookId the user's facebook ID
2606            * @param openId the user's OpenID
2607            * @param locale the user's locale
2608            * @param firstName the user's first name
2609            * @param middleName the user's middle name
2610            * @param lastName the user's last name
2611            * @param prefixId the user's name prefix ID
2612            * @param suffixId the user's name suffix ID
2613            * @param male whether the user is male
2614            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
2615            January)
2616            * @param birthdayDay the user's birthday day
2617            * @param birthdayYear the user's birthday year
2618            * @param jobTitle the user's job title
2619            * @param updateUserInformation whether to update the user's information
2620            * @param sendEmail whether to send the user an email notification about
2621            their new account
2622            * @param serviceContext the service context to be applied (optionally
2623            <code>null</code>). Can set expando bridge attributes for the
2624            user.
2625            * @return the user
2626            */
2627            public static com.liferay.portal.model.User updateIncompleteUser(
2628                    long creatorUserId, long companyId, boolean autoPassword,
2629                    java.lang.String password1, java.lang.String password2,
2630                    boolean autoScreenName, java.lang.String screenName,
2631                    java.lang.String emailAddress, long facebookId,
2632                    java.lang.String openId, java.util.Locale locale,
2633                    java.lang.String firstName, java.lang.String middleName,
2634                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
2635                    int birthdayMonth, int birthdayDay, int birthdayYear,
2636                    java.lang.String jobTitle, boolean updateUserInformation,
2637                    boolean sendEmail,
2638                    com.liferay.portal.service.ServiceContext serviceContext)
2639                    throws com.liferay.portal.kernel.exception.PortalException {
2640                    return getService()
2641                                       .updateIncompleteUser(creatorUserId, companyId,
2642                            autoPassword, password1, password2, autoScreenName, screenName,
2643                            emailAddress, facebookId, openId, locale, firstName, middleName,
2644                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
2645                            birthdayYear, jobTitle, updateUserInformation, sendEmail,
2646                            serviceContext);
2647            }
2648    
2649            /**
2650            * Updates the user's job title.
2651            *
2652            * @param userId the primary key of the user
2653            * @param jobTitle the user's job title
2654            * @return the user
2655            */
2656            public static com.liferay.portal.model.User updateJobTitle(long userId,
2657                    java.lang.String jobTitle)
2658                    throws com.liferay.portal.kernel.exception.PortalException {
2659                    return getService().updateJobTitle(userId, jobTitle);
2660            }
2661    
2662            /**
2663            * Updates the user's last login with the current time and the IP address.
2664            *
2665            * @param userId the primary key of the user
2666            * @param loginIP the IP address the user logged in from
2667            * @return the user
2668            */
2669            public static com.liferay.portal.model.User updateLastLogin(long userId,
2670                    java.lang.String loginIP)
2671                    throws com.liferay.portal.kernel.exception.PortalException {
2672                    return getService().updateLastLogin(userId, loginIP);
2673            }
2674    
2675            /**
2676            * Updates whether the user is locked out from logging in.
2677            *
2678            * @param user the user
2679            * @param lockout whether the user is locked out
2680            * @return the user
2681            */
2682            public static com.liferay.portal.model.User updateLockout(
2683                    com.liferay.portal.model.User user, boolean lockout)
2684                    throws com.liferay.portal.kernel.exception.PortalException {
2685                    return getService().updateLockout(user, lockout);
2686            }
2687    
2688            /**
2689            * Updates whether the user is locked out from logging in.
2690            *
2691            * @param companyId the primary key of the user's company
2692            * @param emailAddress the user's email address
2693            * @param lockout whether the user is locked out
2694            * @return the user
2695            */
2696            public static com.liferay.portal.model.User updateLockoutByEmailAddress(
2697                    long companyId, java.lang.String emailAddress, boolean lockout)
2698                    throws com.liferay.portal.kernel.exception.PortalException {
2699                    return getService()
2700                                       .updateLockoutByEmailAddress(companyId, emailAddress, lockout);
2701            }
2702    
2703            /**
2704            * Updates whether the user is locked out from logging in.
2705            *
2706            * @param userId the primary key of the user
2707            * @param lockout whether the user is locked out
2708            * @return the user
2709            */
2710            public static com.liferay.portal.model.User updateLockoutById(long userId,
2711                    boolean lockout)
2712                    throws com.liferay.portal.kernel.exception.PortalException {
2713                    return getService().updateLockoutById(userId, lockout);
2714            }
2715    
2716            /**
2717            * Updates whether the user is locked out from logging in.
2718            *
2719            * @param companyId the primary key of the user's company
2720            * @param screenName the user's screen name
2721            * @param lockout whether the user is locked out
2722            * @return the user
2723            */
2724            public static com.liferay.portal.model.User updateLockoutByScreenName(
2725                    long companyId, java.lang.String screenName, boolean lockout)
2726                    throws com.liferay.portal.kernel.exception.PortalException {
2727                    return getService()
2728                                       .updateLockoutByScreenName(companyId, screenName, lockout);
2729            }
2730    
2731            /**
2732            * Updates the user's modified date.
2733            *
2734            * @param userId the primary key of the user
2735            * @param modifiedDate the new modified date
2736            * @return the user
2737            */
2738            public static com.liferay.portal.model.User updateModifiedDate(
2739                    long userId, java.util.Date modifiedDate)
2740                    throws com.liferay.portal.kernel.exception.PortalException {
2741                    return getService().updateModifiedDate(userId, modifiedDate);
2742            }
2743    
2744            /**
2745            * Updates the user's OpenID.
2746            *
2747            * @param userId the primary key of the user
2748            * @param openId the new OpenID
2749            * @return the user
2750            */
2751            public static com.liferay.portal.model.User updateOpenId(long userId,
2752                    java.lang.String openId)
2753                    throws com.liferay.portal.kernel.exception.PortalException {
2754                    return getService().updateOpenId(userId, openId);
2755            }
2756    
2757            /**
2758            * Sets the organizations that the user is in, removing and adding
2759            * organizations as necessary.
2760            *
2761            * @param userId the primary key of the user
2762            * @param newOrganizationIds the primary keys of the organizations
2763            * @param serviceContext the service context to be applied. Must set whether
2764            user indexing is enabled.
2765            */
2766            public static void updateOrganizations(long userId,
2767                    long[] newOrganizationIds,
2768                    com.liferay.portal.service.ServiceContext serviceContext)
2769                    throws com.liferay.portal.kernel.exception.PortalException {
2770                    getService()
2771                            .updateOrganizations(userId, newOrganizationIds, serviceContext);
2772            }
2773    
2774            /**
2775            * Updates the user's password without tracking or validation of the change.
2776            *
2777            * @param userId the primary key of the user
2778            * @param password1 the user's new password
2779            * @param password2 the user's new password confirmation
2780            * @param passwordReset whether the user should be asked to reset their
2781            password the next time they log in
2782            * @return the user
2783            */
2784            public static com.liferay.portal.model.User updatePassword(long userId,
2785                    java.lang.String password1, java.lang.String password2,
2786                    boolean passwordReset)
2787                    throws com.liferay.portal.kernel.exception.PortalException {
2788                    return getService()
2789                                       .updatePassword(userId, password1, password2, passwordReset);
2790            }
2791    
2792            /**
2793            * Updates the user's password, optionally with tracking and validation of
2794            * the change.
2795            *
2796            * @param userId the primary key of the user
2797            * @param password1 the user's new password
2798            * @param password2 the user's new password confirmation
2799            * @param passwordReset whether the user should be asked to reset their
2800            password the next time they login
2801            * @param silentUpdate whether the password should be updated without being
2802            tracked, or validated. Primarily used for password imports.
2803            * @return the user
2804            */
2805            public static com.liferay.portal.model.User updatePassword(long userId,
2806                    java.lang.String password1, java.lang.String password2,
2807                    boolean passwordReset, boolean silentUpdate)
2808                    throws com.liferay.portal.kernel.exception.PortalException {
2809                    return getService()
2810                                       .updatePassword(userId, password1, password2, passwordReset,
2811                            silentUpdate);
2812            }
2813    
2814            /**
2815            * Updates the user's password with manually input information. This method
2816            * should only be used when performing maintenance.
2817            *
2818            * @param userId the primary key of the user
2819            * @param password the user's new password
2820            * @param passwordEncrypted the user's new encrypted password
2821            * @param passwordReset whether the user should be asked to reset their
2822            password the next time they login
2823            * @param passwordModifiedDate the new password modified date
2824            * @return the user
2825            */
2826            public static com.liferay.portal.model.User updatePasswordManually(
2827                    long userId, java.lang.String password, boolean passwordEncrypted,
2828                    boolean passwordReset, java.util.Date passwordModifiedDate)
2829                    throws com.liferay.portal.kernel.exception.PortalException {
2830                    return getService()
2831                                       .updatePasswordManually(userId, password, passwordEncrypted,
2832                            passwordReset, passwordModifiedDate);
2833            }
2834    
2835            /**
2836            * Updates whether the user should be asked to reset their password the next
2837            * time they login.
2838            *
2839            * @param userId the primary key of the user
2840            * @param passwordReset whether the user should be asked to reset their
2841            password the next time they login
2842            * @return the user
2843            */
2844            public static com.liferay.portal.model.User updatePasswordReset(
2845                    long userId, boolean passwordReset)
2846                    throws com.liferay.portal.kernel.exception.PortalException {
2847                    return getService().updatePasswordReset(userId, passwordReset);
2848            }
2849    
2850            /**
2851            * Updates the user's portrait image.
2852            *
2853            * @param userId the primary key of the user
2854            * @param bytes the new portrait image data
2855            * @return the user
2856            */
2857            public static com.liferay.portal.model.User updatePortrait(long userId,
2858                    byte[] bytes)
2859                    throws com.liferay.portal.kernel.exception.PortalException {
2860                    return getService().updatePortrait(userId, bytes);
2861            }
2862    
2863            /**
2864            * Updates the user's password reset question and answer.
2865            *
2866            * @param userId the primary key of the user
2867            * @param question the user's new password reset question
2868            * @param answer the user's new password reset answer
2869            * @return the user
2870            */
2871            public static com.liferay.portal.model.User updateReminderQuery(
2872                    long userId, java.lang.String question, java.lang.String answer)
2873                    throws com.liferay.portal.kernel.exception.PortalException {
2874                    return getService().updateReminderQuery(userId, question, answer);
2875            }
2876    
2877            /**
2878            * Updates the user's screen name.
2879            *
2880            * @param userId the primary key of the user
2881            * @param screenName the user's new screen name
2882            * @return the user
2883            */
2884            public static com.liferay.portal.model.User updateScreenName(long userId,
2885                    java.lang.String screenName)
2886                    throws com.liferay.portal.kernel.exception.PortalException {
2887                    return getService().updateScreenName(userId, screenName);
2888            }
2889    
2890            /**
2891            * Updates the user's workflow status.
2892            *
2893            * @param userId the primary key of the user
2894            * @param status the user's new workflow status
2895            * @return the user
2896            * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int,
2897            ServiceContext)}
2898            */
2899            @Deprecated
2900            public static com.liferay.portal.model.User updateStatus(long userId,
2901                    int status) throws com.liferay.portal.kernel.exception.PortalException {
2902                    return getService().updateStatus(userId, status);
2903            }
2904    
2905            /**
2906            * Updates the user's workflow status.
2907            *
2908            * @param userId the primary key of the user
2909            * @param status the user's new workflow status
2910            * @param serviceContext the service context to be applied. You can specify
2911            an unencrypted custom password (used by an LDAP listener) for the
2912            user via attribute <code>passwordUnencrypted</code>.
2913            * @return the user
2914            */
2915            public static com.liferay.portal.model.User updateStatus(long userId,
2916                    int status, com.liferay.portal.service.ServiceContext serviceContext)
2917                    throws com.liferay.portal.kernel.exception.PortalException {
2918                    return getService().updateStatus(userId, status, serviceContext);
2919            }
2920    
2921            /**
2922            * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
2923            *
2924            * @param user the user
2925            * @return the user that was updated
2926            */
2927            public static com.liferay.portal.model.User updateUser(
2928                    com.liferay.portal.model.User user) {
2929                    return getService().updateUser(user);
2930            }
2931    
2932            /**
2933            * Updates the user.
2934            *
2935            * @param userId the primary key of the user
2936            * @param oldPassword the user's old password
2937            * @param newPassword1 the user's new password (optionally
2938            <code>null</code>)
2939            * @param newPassword2 the user's new password confirmation (optionally
2940            <code>null</code>)
2941            * @param passwordReset whether the user should be asked to reset their
2942            password the next time they login
2943            * @param reminderQueryQuestion the user's new password reset question
2944            * @param reminderQueryAnswer the user's new password reset answer
2945            * @param screenName the user's new screen name
2946            * @param emailAddress the user's new email address
2947            * @param facebookId the user's new Facebook ID
2948            * @param openId the user's new OpenID
2949            * @param languageId the user's new language ID
2950            * @param timeZoneId the user's new time zone ID
2951            * @param greeting the user's new greeting
2952            * @param comments the user's new comments
2953            * @param firstName the user's new first name
2954            * @param middleName the user's new middle name
2955            * @param lastName the user's new last name
2956            * @param prefixId the user's new name prefix ID
2957            * @param suffixId the user's new name suffix ID
2958            * @param male whether user is male
2959            * @param birthdayMonth the user's new birthday month (0-based, meaning
2960            0 for January)
2961            * @param birthdayDay the user's new birthday day
2962            * @param birthdayYear the user's birthday year
2963            * @param smsSn the user's new SMS screen name
2964            * @param facebookSn the user's new Facebook screen name
2965            * @param jabberSn the user's new Jabber screen name
2966            * @param skypeSn the user's new Skype screen name
2967            * @param twitterSn the user's new Twitter screen name
2968            * @param jobTitle the user's new job title
2969            * @param groupIds the primary keys of the user's groups
2970            * @param organizationIds the primary keys of the user's organizations
2971            * @param roleIds the primary keys of the user's roles
2972            * @param userGroupRoles the user user's group roles
2973            * @param userGroupIds the primary keys of the user's user groups
2974            * @param serviceContext the service context to be applied (optionally
2975            <code>null</code>). Can set the UUID (with the
2976            <code>uuid</code> attribute), asset category IDs, asset tag
2977            names, and expando bridge attributes for the user.
2978            * @return the user
2979            * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String,
2980            String, String, boolean, String, String, String, String,
2981            long, String, boolean, byte[], String, String, String,
2982            String, String, String, String, long, long, boolean, int,
2983            int, int, String, String, String, String, String, String,
2984            long[], long[], long[], List, long[], ServiceContext)}
2985            */
2986            @Deprecated
2987            public static com.liferay.portal.model.User updateUser(long userId,
2988                    java.lang.String oldPassword, java.lang.String newPassword1,
2989                    java.lang.String newPassword2, boolean passwordReset,
2990                    java.lang.String reminderQueryQuestion,
2991                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
2992                    java.lang.String emailAddress, long facebookId,
2993                    java.lang.String openId, java.lang.String languageId,
2994                    java.lang.String timeZoneId, java.lang.String greeting,
2995                    java.lang.String comments, java.lang.String firstName,
2996                    java.lang.String middleName, java.lang.String lastName, long prefixId,
2997                    long suffixId, boolean male, int birthdayMonth, int birthdayDay,
2998                    int birthdayYear, java.lang.String smsSn, java.lang.String facebookSn,
2999                    java.lang.String jabberSn, java.lang.String skypeSn,
3000                    java.lang.String twitterSn, java.lang.String jobTitle, long[] groupIds,
3001                    long[] organizationIds, long[] roleIds,
3002                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3003                    long[] userGroupIds,
3004                    com.liferay.portal.service.ServiceContext serviceContext)
3005                    throws com.liferay.portal.kernel.exception.PortalException {
3006                    return getService()
3007                                       .updateUser(userId, oldPassword, newPassword1, newPassword2,
3008                            passwordReset, reminderQueryQuestion, reminderQueryAnswer,
3009                            screenName, emailAddress, facebookId, openId, languageId,
3010                            timeZoneId, greeting, comments, firstName, middleName, lastName,
3011                            prefixId, suffixId, male, birthdayMonth, birthdayDay, birthdayYear,
3012                            smsSn, facebookSn, jabberSn, skypeSn, twitterSn, jobTitle,
3013                            groupIds, organizationIds, roleIds, userGroupRoles, userGroupIds,
3014                            serviceContext);
3015            }
3016    
3017            /**
3018            * Updates the user.
3019            *
3020            * @param userId the primary key of the user
3021            * @param oldPassword the user's old password
3022            * @param newPassword1 the user's new password (optionally
3023            <code>null</code>)
3024            * @param newPassword2 the user's new password confirmation (optionally
3025            <code>null</code>)
3026            * @param passwordReset whether the user should be asked to reset their
3027            password the next time they login
3028            * @param reminderQueryQuestion the user's new password reset question
3029            * @param reminderQueryAnswer the user's new password reset answer
3030            * @param screenName the user's new screen name
3031            * @param emailAddress the user's new email address
3032            * @param facebookId the user's new Facebook ID
3033            * @param openId the user's new OpenID
3034            * @param portrait whether to update the user's portrait image
3035            * @param portraitBytes the new portrait image data
3036            * @param languageId the user's new language ID
3037            * @param timeZoneId the user's new time zone ID
3038            * @param greeting the user's new greeting
3039            * @param comments the user's new comments
3040            * @param firstName the user's new first name
3041            * @param middleName the user's new middle name
3042            * @param lastName the user's new last name
3043            * @param prefixId the user's new name prefix ID
3044            * @param suffixId the user's new name suffix ID
3045            * @param male whether user is male
3046            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
3047            for January)
3048            * @param birthdayDay the user's new birthday day
3049            * @param birthdayYear the user's birthday year
3050            * @param smsSn the user's new SMS screen name
3051            * @param facebookSn the user's new Facebook screen name
3052            * @param jabberSn the user's new Jabber screen name
3053            * @param skypeSn the user's new Skype screen name
3054            * @param twitterSn the user's new Twitter screen name
3055            * @param jobTitle the user's new job title
3056            * @param groupIds the primary keys of the user's groups
3057            * @param organizationIds the primary keys of the user's organizations
3058            * @param roleIds the primary keys of the user's roles
3059            * @param userGroupRoles the user user's group roles
3060            * @param userGroupIds the primary keys of the user's user groups
3061            * @param serviceContext the service context to be applied (optionally
3062            <code>null</code>). Can set the UUID (with the <code>uuid</code>
3063            attribute), asset category IDs, asset tag names, and expando
3064            bridge attributes for the user.
3065            * @return the user
3066            */
3067            public static com.liferay.portal.model.User updateUser(long userId,
3068                    java.lang.String oldPassword, java.lang.String newPassword1,
3069                    java.lang.String newPassword2, boolean passwordReset,
3070                    java.lang.String reminderQueryQuestion,
3071                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3072                    java.lang.String emailAddress, long facebookId,
3073                    java.lang.String openId, boolean portrait, byte[] portraitBytes,
3074                    java.lang.String languageId, java.lang.String timeZoneId,
3075                    java.lang.String greeting, java.lang.String comments,
3076                    java.lang.String firstName, java.lang.String middleName,
3077                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
3078                    int birthdayMonth, int birthdayDay, int birthdayYear,
3079                    java.lang.String smsSn, java.lang.String facebookSn,
3080                    java.lang.String jabberSn, java.lang.String skypeSn,
3081                    java.lang.String twitterSn, java.lang.String jobTitle, long[] groupIds,
3082                    long[] organizationIds, long[] roleIds,
3083                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3084                    long[] userGroupIds,
3085                    com.liferay.portal.service.ServiceContext serviceContext)
3086                    throws com.liferay.portal.kernel.exception.PortalException {
3087                    return getService()
3088                                       .updateUser(userId, oldPassword, newPassword1, newPassword2,
3089                            passwordReset, reminderQueryQuestion, reminderQueryAnswer,
3090                            screenName, emailAddress, facebookId, openId, portrait,
3091                            portraitBytes, languageId, timeZoneId, greeting, comments,
3092                            firstName, middleName, lastName, prefixId, suffixId, male,
3093                            birthdayMonth, birthdayDay, birthdayYear, smsSn, facebookSn,
3094                            jabberSn, skypeSn, twitterSn, jobTitle, groupIds, organizationIds,
3095                            roleIds, userGroupRoles, userGroupIds, serviceContext);
3096            }
3097    
3098            /**
3099            * Verifies the email address of the ticket.
3100            *
3101            * @param ticketKey the ticket key
3102            */
3103            public static void verifyEmailAddress(java.lang.String ticketKey)
3104                    throws com.liferay.portal.kernel.exception.PortalException {
3105                    getService().verifyEmailAddress(ticketKey);
3106            }
3107    
3108            public static UserLocalService getService() {
3109                    if (_service == null) {
3110                            _service = (UserLocalService)PortalBeanLocatorUtil.locate(UserLocalService.class.getName());
3111    
3112                            ReferenceRegistry.registerReference(UserLocalServiceUtil.class,
3113                                    "_service");
3114                    }
3115    
3116                    return _service;
3117            }
3118    
3119            private static UserLocalService _service;
3120    }