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