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