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