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