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, int prefixId, int 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, int prefixId, int 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.portal.kernel.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            boolean, 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            @Override
2514            public boolean sendPasswordByEmailAddress(long companyId,
2515                    java.lang.String emailAddress)
2516                    throws com.liferay.portal.kernel.exception.PortalException {
2517                    return _userLocalService.sendPasswordByEmailAddress(companyId,
2518                            emailAddress);
2519            }
2520    
2521            @Override
2522            public boolean sendPasswordByScreenName(long companyId,
2523                    java.lang.String screenName)
2524                    throws com.liferay.portal.kernel.exception.PortalException {
2525                    return _userLocalService.sendPasswordByScreenName(companyId, screenName);
2526            }
2527    
2528            @Override
2529            public boolean sendPasswordByUserId(long userId)
2530                    throws com.liferay.portal.kernel.exception.PortalException {
2531                    return _userLocalService.sendPasswordByUserId(userId);
2532            }
2533    
2534            /**
2535            * Sets the Spring bean ID for this bean.
2536            *
2537            * @param beanIdentifier the Spring bean ID for this bean
2538            */
2539            @Override
2540            public void setBeanIdentifier(java.lang.String beanIdentifier) {
2541                    _userLocalService.setBeanIdentifier(beanIdentifier);
2542            }
2543    
2544            @Override
2545            public void setGroupUsers(long groupId, long[] userIds) {
2546                    _userLocalService.setGroupUsers(groupId, userIds);
2547            }
2548    
2549            @Override
2550            public void setOrganizationUsers(long organizationId, long[] userIds) {
2551                    _userLocalService.setOrganizationUsers(organizationId, userIds);
2552            }
2553    
2554            /**
2555            * @throws PortalException
2556            */
2557            @Override
2558            public void setRoleUsers(long roleId, long[] userIds)
2559                    throws com.liferay.portal.kernel.exception.PortalException {
2560                    _userLocalService.setRoleUsers(roleId, userIds);
2561            }
2562    
2563            @Override
2564            public void setTeamUsers(long teamId, long[] userIds) {
2565                    _userLocalService.setTeamUsers(teamId, userIds);
2566            }
2567    
2568            /**
2569            * @throws PortalException
2570            */
2571            @Override
2572            public void setUserGroupUsers(long userGroupId, long[] userIds)
2573                    throws com.liferay.portal.kernel.exception.PortalException {
2574                    _userLocalService.setUserGroupUsers(userGroupId, userIds);
2575            }
2576    
2577            /**
2578            * Removes the users from the teams of a group.
2579            *
2580            * @param groupId the primary key of the group
2581            * @param userIds the primary keys of the users
2582            * @throws PortalException if a portal exception occurred
2583            */
2584            @Override
2585            public void unsetGroupTeamsUsers(long groupId, long[] userIds)
2586                    throws com.liferay.portal.kernel.exception.PortalException {
2587                    _userLocalService.unsetGroupTeamsUsers(groupId, userIds);
2588            }
2589    
2590            /**
2591            * Removes the users from the group.
2592            *
2593            * @param groupId the primary key of the group
2594            * @param userIds the primary keys of the users
2595            * @param serviceContext the service context to be applied (optionally
2596            <code>null</code>)
2597            * @throws PortalException if a portal exception occurred
2598            */
2599            @Override
2600            public void unsetGroupUsers(long groupId, long[] userIds,
2601                    com.liferay.portal.service.ServiceContext serviceContext)
2602                    throws com.liferay.portal.kernel.exception.PortalException {
2603                    _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext);
2604            }
2605    
2606            /**
2607            * Removes the users from the organization.
2608            *
2609            * @param organizationId the primary key of the organization
2610            * @param userIds the primary keys of the users
2611            * @throws PortalException if a portal exception occurred
2612            */
2613            @Override
2614            public void unsetOrganizationUsers(long organizationId, long[] userIds)
2615                    throws com.liferay.portal.kernel.exception.PortalException {
2616                    _userLocalService.unsetOrganizationUsers(organizationId, userIds);
2617            }
2618    
2619            /**
2620            * Removes the users from the password policy.
2621            *
2622            * @param passwordPolicyId the primary key of the password policy
2623            * @param userIds the primary keys of the users
2624            */
2625            @Override
2626            public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds) {
2627                    _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
2628            }
2629    
2630            /**
2631            * Removes the users from the role.
2632            *
2633            * @param roleId the primary key of the role
2634            * @param userIds the primary keys of the users
2635            * @throws PortalException if a portal exception occurred
2636            */
2637            @Override
2638            public void unsetRoleUsers(long roleId, long[] userIds)
2639                    throws com.liferay.portal.kernel.exception.PortalException {
2640                    _userLocalService.unsetRoleUsers(roleId, userIds);
2641            }
2642    
2643            /**
2644            * Removes the users from the role.
2645            *
2646            * @param roleId the primary key of the role
2647            * @param users the users
2648            * @throws PortalException if a portal exception occurred
2649            */
2650            @Override
2651            public void unsetRoleUsers(long roleId,
2652                    java.util.List<com.liferay.portal.model.User> users)
2653                    throws com.liferay.portal.kernel.exception.PortalException {
2654                    _userLocalService.unsetRoleUsers(roleId, users);
2655            }
2656    
2657            /**
2658            * Removes the users from the team.
2659            *
2660            * @param teamId the primary key of the team
2661            * @param userIds the primary keys of the users
2662            * @throws PortalException if a portal exception occurred
2663            */
2664            @Override
2665            public void unsetTeamUsers(long teamId, long[] userIds)
2666                    throws com.liferay.portal.kernel.exception.PortalException {
2667                    _userLocalService.unsetTeamUsers(teamId, userIds);
2668            }
2669    
2670            /**
2671            * Removes the users from the user group.
2672            *
2673            * @param userGroupId the primary key of the user group
2674            * @param userIds the primary keys of the users
2675            * @throws PortalException if a portal exception occurred
2676            */
2677            @Override
2678            public void unsetUserGroupUsers(long userGroupId, long[] userIds)
2679                    throws com.liferay.portal.kernel.exception.PortalException {
2680                    _userLocalService.unsetUserGroupUsers(userGroupId, userIds);
2681            }
2682    
2683            /**
2684            * Updates whether the user has agreed to the terms of use.
2685            *
2686            * @param userId the primary key of the user
2687            * @param agreedToTermsOfUse whether the user has agreet to the terms of
2688            use
2689            * @return the user
2690            * @throws PortalException if a user with the primary key could not be found
2691            */
2692            @Override
2693            public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId,
2694                    boolean agreedToTermsOfUse)
2695                    throws com.liferay.portal.kernel.exception.PortalException {
2696                    return _userLocalService.updateAgreedToTermsOfUse(userId,
2697                            agreedToTermsOfUse);
2698            }
2699    
2700            /**
2701            * Updates the user's asset with the new asset categories and tag names,
2702            * removing and adding asset categories and tag names as necessary.
2703            *
2704            * @param userId the primary key of the user
2705            * @param user ID the primary key of the user
2706            * @param assetCategoryIds the primary key's of the new asset categories
2707            * @param assetTagNames the new asset tag names
2708            * @throws PortalException if a user with the primary key could not be found
2709            */
2710            @Override
2711            public void updateAsset(long userId, com.liferay.portal.model.User user,
2712                    long[] assetCategoryIds, java.lang.String[] assetTagNames)
2713                    throws com.liferay.portal.kernel.exception.PortalException {
2714                    _userLocalService.updateAsset(userId, user, assetCategoryIds,
2715                            assetTagNames);
2716            }
2717    
2718            /**
2719            * Updates the user's creation date.
2720            *
2721            * @param userId the primary key of the user
2722            * @param createDate the new creation date
2723            * @return the user
2724            * @throws PortalException if a user with the primary key could not be found
2725            */
2726            @Override
2727            public com.liferay.portal.model.User updateCreateDate(long userId,
2728                    java.util.Date createDate)
2729                    throws com.liferay.portal.kernel.exception.PortalException {
2730                    return _userLocalService.updateCreateDate(userId, createDate);
2731            }
2732    
2733            /**
2734            * Updates the user's email address.
2735            *
2736            * @param userId the primary key of the user
2737            * @param password the user's password
2738            * @param emailAddress1 the user's new email address
2739            * @param emailAddress2 the user's new email address confirmation
2740            * @return the user
2741            * @throws PortalException if a user with the primary key could not be found
2742            */
2743            @Override
2744            public com.liferay.portal.model.User updateEmailAddress(long userId,
2745                    java.lang.String password, java.lang.String emailAddress1,
2746                    java.lang.String emailAddress2)
2747                    throws com.liferay.portal.kernel.exception.PortalException {
2748                    return _userLocalService.updateEmailAddress(userId, password,
2749                            emailAddress1, emailAddress2);
2750            }
2751    
2752            /**
2753            * Updates the user's email address or sends verification email.
2754            *
2755            * @param userId the primary key of the user
2756            * @param password the user's password
2757            * @param emailAddress1 the user's new email address
2758            * @param emailAddress2 the user's new email address confirmation
2759            * @param serviceContext the service context to be applied. Must set the
2760            portal URL, main path, primary key of the layout, remote address,
2761            remote host, and agent for the user.
2762            * @return the user
2763            * @throws PortalException if a user with the primary key could not be found
2764            */
2765            @Override
2766            public com.liferay.portal.model.User updateEmailAddress(long userId,
2767                    java.lang.String password, java.lang.String emailAddress1,
2768                    java.lang.String emailAddress2,
2769                    com.liferay.portal.service.ServiceContext serviceContext)
2770                    throws com.liferay.portal.kernel.exception.PortalException {
2771                    return _userLocalService.updateEmailAddress(userId, password,
2772                            emailAddress1, emailAddress2, serviceContext);
2773            }
2774    
2775            /**
2776            * Updates whether the user has verified email address.
2777            *
2778            * @param userId the primary key of the user
2779            * @param emailAddressVerified whether the user has verified email address
2780            * @return the user
2781            * @throws PortalException if a user with the primary key could not be found
2782            */
2783            @Override
2784            public com.liferay.portal.model.User updateEmailAddressVerified(
2785                    long userId, boolean emailAddressVerified)
2786                    throws com.liferay.portal.kernel.exception.PortalException {
2787                    return _userLocalService.updateEmailAddressVerified(userId,
2788                            emailAddressVerified);
2789            }
2790    
2791            /**
2792            * Updates the user's Facebook ID.
2793            *
2794            * @param userId the primary key of the user
2795            * @param facebookId the user's new Facebook ID
2796            * @return the user
2797            * @throws PortalException if a user with the primary key could not be found
2798            */
2799            @Override
2800            public com.liferay.portal.model.User updateFacebookId(long userId,
2801                    long facebookId)
2802                    throws com.liferay.portal.kernel.exception.PortalException {
2803                    return _userLocalService.updateFacebookId(userId, facebookId);
2804            }
2805    
2806            /**
2807            * Sets the groups the user is in, removing and adding groups as necessary.
2808            *
2809            * @param userId the primary key of the user
2810            * @param newGroupIds the primary keys of the groups
2811            * @param serviceContext the service context to be applied (optionally
2812            <code>null</code>)
2813            * @throws PortalException if a portal exception occurred
2814            */
2815            @Override
2816            public void updateGroups(long userId, long[] newGroupIds,
2817                    com.liferay.portal.service.ServiceContext serviceContext)
2818                    throws com.liferay.portal.kernel.exception.PortalException {
2819                    _userLocalService.updateGroups(userId, newGroupIds, serviceContext);
2820            }
2821    
2822            /**
2823            * Updates a user account that was automatically created when a guest user
2824            * participated in an action (e.g. posting a comment) and only provided his
2825            * name and email address.
2826            *
2827            * @param creatorUserId the primary key of the creator
2828            * @param companyId the primary key of the user's company
2829            * @param autoPassword whether a password should be automatically generated
2830            for the user
2831            * @param password1 the user's password
2832            * @param password2 the user's password confirmation
2833            * @param autoScreenName whether a screen name should be automatically
2834            generated for the user
2835            * @param screenName the user's screen name
2836            * @param emailAddress the user's email address
2837            * @param facebookId the user's facebook ID
2838            * @param openId the user's OpenID
2839            * @param locale the user's locale
2840            * @param firstName the user's first name
2841            * @param middleName the user's middle name
2842            * @param lastName the user's last name
2843            * @param prefixId the user's name prefix ID
2844            * @param suffixId the user's name suffix ID
2845            * @param male whether the user is male
2846            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
2847            January)
2848            * @param birthdayDay the user's birthday day
2849            * @param birthdayYear the user's birthday year
2850            * @param jobTitle the user's job title
2851            * @param updateUserInformation whether to update the user's information
2852            * @param sendEmail whether to send the user an email notification about
2853            their new account
2854            * @param serviceContext the service context to be applied (optionally
2855            <code>null</code>). Can set expando bridge attributes for the
2856            user.
2857            * @return the user
2858            * @throws PortalException if the user's information was invalid
2859            */
2860            @Override
2861            public com.liferay.portal.model.User updateIncompleteUser(
2862                    long creatorUserId, long companyId, boolean autoPassword,
2863                    java.lang.String password1, java.lang.String password2,
2864                    boolean autoScreenName, java.lang.String screenName,
2865                    java.lang.String emailAddress, long facebookId,
2866                    java.lang.String openId, java.util.Locale locale,
2867                    java.lang.String firstName, java.lang.String middleName,
2868                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
2869                    int birthdayMonth, int birthdayDay, int birthdayYear,
2870                    java.lang.String jobTitle, boolean updateUserInformation,
2871                    boolean sendEmail,
2872                    com.liferay.portal.service.ServiceContext serviceContext)
2873                    throws com.liferay.portal.kernel.exception.PortalException {
2874                    return _userLocalService.updateIncompleteUser(creatorUserId, companyId,
2875                            autoPassword, password1, password2, autoScreenName, screenName,
2876                            emailAddress, facebookId, openId, locale, firstName, middleName,
2877                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
2878                            birthdayYear, jobTitle, updateUserInformation, sendEmail,
2879                            serviceContext);
2880            }
2881    
2882            /**
2883            * Updates the user's job title.
2884            *
2885            * @param userId the primary key of the user
2886            * @param jobTitle the user's job title
2887            * @return the user
2888            * @throws PortalException if a user with the primary key could not be found
2889            or if a contact could not be found matching the user's contact ID
2890            */
2891            @Override
2892            public com.liferay.portal.model.User updateJobTitle(long userId,
2893                    java.lang.String jobTitle)
2894                    throws com.liferay.portal.kernel.exception.PortalException {
2895                    return _userLocalService.updateJobTitle(userId, jobTitle);
2896            }
2897    
2898            /**
2899            * Updates the user's last login with the current time and the IP address.
2900            *
2901            * @param userId the primary key of the user
2902            * @param loginIP the IP address the user logged in from
2903            * @return the user
2904            * @throws PortalException if a user with the primary key could not be found
2905            */
2906            @Override
2907            public com.liferay.portal.model.User updateLastLogin(long userId,
2908                    java.lang.String loginIP)
2909                    throws com.liferay.portal.kernel.exception.PortalException {
2910                    return _userLocalService.updateLastLogin(userId, loginIP);
2911            }
2912    
2913            /**
2914            * Updates whether the user is locked out from logging in.
2915            *
2916            * @param user the user
2917            * @param lockout whether the user is locked out
2918            * @return the user
2919            * @throws PortalException if a portal exception occurred
2920            */
2921            @Override
2922            public com.liferay.portal.model.User updateLockout(
2923                    com.liferay.portal.model.User user, boolean lockout)
2924                    throws com.liferay.portal.kernel.exception.PortalException {
2925                    return _userLocalService.updateLockout(user, lockout);
2926            }
2927    
2928            /**
2929            * Updates whether the user is locked out from logging in.
2930            *
2931            * @param companyId the primary key of the user's company
2932            * @param emailAddress the user's email address
2933            * @param lockout whether the user is locked out
2934            * @return the user
2935            * @throws PortalException if a user with the email address could not be
2936            found
2937            */
2938            @Override
2939            public com.liferay.portal.model.User updateLockoutByEmailAddress(
2940                    long companyId, java.lang.String emailAddress, boolean lockout)
2941                    throws com.liferay.portal.kernel.exception.PortalException {
2942                    return _userLocalService.updateLockoutByEmailAddress(companyId,
2943                            emailAddress, lockout);
2944            }
2945    
2946            /**
2947            * Updates whether the user is locked out from logging in.
2948            *
2949            * @param userId the primary key of the user
2950            * @param lockout whether the user is locked out
2951            * @return the user
2952            * @throws PortalException if a user with the primary key could not be found
2953            */
2954            @Override
2955            public com.liferay.portal.model.User updateLockoutById(long userId,
2956                    boolean lockout)
2957                    throws com.liferay.portal.kernel.exception.PortalException {
2958                    return _userLocalService.updateLockoutById(userId, lockout);
2959            }
2960    
2961            /**
2962            * Updates whether the user is locked out from logging in.
2963            *
2964            * @param companyId the primary key of the user's company
2965            * @param screenName the user's screen name
2966            * @param lockout whether the user is locked out
2967            * @return the user
2968            * @throws PortalException if a user with the screen name could not be found
2969            */
2970            @Override
2971            public com.liferay.portal.model.User updateLockoutByScreenName(
2972                    long companyId, java.lang.String screenName, boolean lockout)
2973                    throws com.liferay.portal.kernel.exception.PortalException {
2974                    return _userLocalService.updateLockoutByScreenName(companyId,
2975                            screenName, lockout);
2976            }
2977    
2978            /**
2979            * Updates the user's modified date.
2980            *
2981            * @param userId the primary key of the user
2982            * @param modifiedDate the new modified date
2983            * @return the user
2984            * @throws PortalException if a user with the primary key could not be found
2985            */
2986            @Override
2987            public com.liferay.portal.model.User updateModifiedDate(long userId,
2988                    java.util.Date modifiedDate)
2989                    throws com.liferay.portal.kernel.exception.PortalException {
2990                    return _userLocalService.updateModifiedDate(userId, modifiedDate);
2991            }
2992    
2993            /**
2994            * Updates the user's OpenID.
2995            *
2996            * @param userId the primary key of the user
2997            * @param openId the new OpenID
2998            * @return the user
2999            * @throws PortalException if a user with the primary key could not be found
3000            */
3001            @Override
3002            public com.liferay.portal.model.User updateOpenId(long userId,
3003                    java.lang.String openId)
3004                    throws com.liferay.portal.kernel.exception.PortalException {
3005                    return _userLocalService.updateOpenId(userId, openId);
3006            }
3007    
3008            /**
3009            * Sets the organizations that the user is in, removing and adding
3010            * organizations as necessary.
3011            *
3012            * @param userId the primary key of the user
3013            * @param newOrganizationIds the primary keys of the organizations
3014            * @param serviceContext the service context to be applied. Must set
3015            whether user indexing is enabled.
3016            * @throws PortalException if a user with the primary key could not be found
3017            */
3018            @Override
3019            public void updateOrganizations(long userId, long[] newOrganizationIds,
3020                    com.liferay.portal.service.ServiceContext serviceContext)
3021                    throws com.liferay.portal.kernel.exception.PortalException {
3022                    _userLocalService.updateOrganizations(userId, newOrganizationIds,
3023                            serviceContext);
3024            }
3025    
3026            /**
3027            * Updates the user's password without tracking or validation of the change.
3028            *
3029            * @param userId the primary key of the user
3030            * @param password1 the user's new password
3031            * @param password2 the user's new password confirmation
3032            * @param passwordReset whether the user should be asked to reset their
3033            password the next time they log in
3034            * @return the user
3035            * @throws PortalException if a user with the primary key could not be found
3036            */
3037            @Override
3038            public com.liferay.portal.model.User updatePassword(long userId,
3039                    java.lang.String password1, java.lang.String password2,
3040                    boolean passwordReset)
3041                    throws com.liferay.portal.kernel.exception.PortalException {
3042                    return _userLocalService.updatePassword(userId, password1, password2,
3043                            passwordReset);
3044            }
3045    
3046            /**
3047            * Updates the user's password, optionally with tracking and validation of
3048            * the change.
3049            *
3050            * @param userId the primary key of the user
3051            * @param password1 the user's new password
3052            * @param password2 the user's new password confirmation
3053            * @param passwordReset whether the user should be asked to reset their
3054            password the next time they login
3055            * @param silentUpdate whether the password should be updated without being
3056            tracked, or validated. Primarily used for password imports.
3057            * @return the user
3058            * @throws PortalException if a user with the primary key could not be found
3059            */
3060            @Override
3061            public com.liferay.portal.model.User updatePassword(long userId,
3062                    java.lang.String password1, java.lang.String password2,
3063                    boolean passwordReset, boolean silentUpdate)
3064                    throws com.liferay.portal.kernel.exception.PortalException {
3065                    return _userLocalService.updatePassword(userId, password1, password2,
3066                            passwordReset, silentUpdate);
3067            }
3068    
3069            /**
3070            * Updates the user's password with manually input information. This method
3071            * should only be used when performing maintenance.
3072            *
3073            * @param userId the primary key of the user
3074            * @param password the user's new password
3075            * @param passwordEncrypted the user's new encrypted password
3076            * @param passwordReset whether the user should be asked to reset their
3077            password the next time they login
3078            * @param passwordModifiedDate the new password modified date
3079            * @return the user
3080            * @throws PortalException if a user with the primary key could not be found
3081            */
3082            @Override
3083            public com.liferay.portal.model.User updatePasswordManually(long userId,
3084                    java.lang.String password, boolean passwordEncrypted,
3085                    boolean passwordReset, java.util.Date passwordModifiedDate)
3086                    throws com.liferay.portal.kernel.exception.PortalException {
3087                    return _userLocalService.updatePasswordManually(userId, password,
3088                            passwordEncrypted, passwordReset, passwordModifiedDate);
3089            }
3090    
3091            /**
3092            * Updates whether the user should be asked to reset their password the next
3093            * time they login.
3094            *
3095            * @param userId the primary key of the user
3096            * @param passwordReset whether the user should be asked to reset their
3097            password the next time they login
3098            * @return the user
3099            * @throws PortalException if a user with the primary key could not be found
3100            */
3101            @Override
3102            public com.liferay.portal.model.User updatePasswordReset(long userId,
3103                    boolean passwordReset)
3104                    throws com.liferay.portal.kernel.exception.PortalException {
3105                    return _userLocalService.updatePasswordReset(userId, passwordReset);
3106            }
3107    
3108            /**
3109            * Updates the user's portrait image.
3110            *
3111            * @param userId the primary key of the user
3112            * @param bytes the new portrait image data
3113            * @return the user
3114            * @throws PortalException if a user with the primary key could not be found
3115            or if the new portrait was invalid
3116            */
3117            @Override
3118            public com.liferay.portal.model.User updatePortrait(long userId,
3119                    byte[] bytes)
3120                    throws com.liferay.portal.kernel.exception.PortalException {
3121                    return _userLocalService.updatePortrait(userId, bytes);
3122            }
3123    
3124            /**
3125            * Updates the user's password reset question and answer.
3126            *
3127            * @param userId the primary key of the user
3128            * @param question the user's new password reset question
3129            * @param answer the user's new password reset answer
3130            * @return the user
3131            * @throws PortalException if a user with the primary key could not be found
3132            or if the new question or answer were invalid
3133            */
3134            @Override
3135            public com.liferay.portal.model.User updateReminderQuery(long userId,
3136                    java.lang.String question, java.lang.String answer)
3137                    throws com.liferay.portal.kernel.exception.PortalException {
3138                    return _userLocalService.updateReminderQuery(userId, question, answer);
3139            }
3140    
3141            /**
3142            * Updates the user's screen name.
3143            *
3144            * @param userId the primary key of the user
3145            * @param screenName the user's new screen name
3146            * @return the user
3147            * @throws PortalException if a user with the primary key could not be found
3148            or if the new screen name was invalid
3149            */
3150            @Override
3151            public com.liferay.portal.model.User updateScreenName(long userId,
3152                    java.lang.String screenName)
3153                    throws com.liferay.portal.kernel.exception.PortalException {
3154                    return _userLocalService.updateScreenName(userId, screenName);
3155            }
3156    
3157            /**
3158            * Updates the user's workflow status.
3159            *
3160            * @param userId the primary key of the user
3161            * @param status the user's new workflow status
3162            * @return the user
3163            * @throws PortalException if a user with the primary key could not be
3164            found
3165            * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int,
3166            ServiceContext)}
3167            */
3168            @Deprecated
3169            @Override
3170            public com.liferay.portal.model.User updateStatus(long userId, int status)
3171                    throws com.liferay.portal.kernel.exception.PortalException {
3172                    return _userLocalService.updateStatus(userId, status);
3173            }
3174    
3175            /**
3176            * Updates the user's workflow status.
3177            *
3178            * @param userId the primary key of the user
3179            * @param status the user's new workflow status
3180            * @param serviceContext the service context to be applied. You can specify
3181            an unencrypted custom password (used by an LDAP listener) for the
3182            user via attribute <code>passwordUnencrypted</code>.
3183            * @return the user
3184            * @throws PortalException if a user with the primary key could not be found
3185            */
3186            @Override
3187            public com.liferay.portal.model.User updateStatus(long userId, int status,
3188                    com.liferay.portal.service.ServiceContext serviceContext)
3189                    throws com.liferay.portal.kernel.exception.PortalException {
3190                    return _userLocalService.updateStatus(userId, status, serviceContext);
3191            }
3192    
3193            /**
3194            * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
3195            *
3196            * @param user the user
3197            * @return the user that was updated
3198            */
3199            @Override
3200            public com.liferay.portal.model.User updateUser(
3201                    com.liferay.portal.model.User user) {
3202                    return _userLocalService.updateUser(user);
3203            }
3204    
3205            /**
3206            * Updates the user.
3207            *
3208            * @param userId the primary key of the user
3209            * @param oldPassword the user's old password
3210            * @param newPassword1 the user's new password (optionally
3211            <code>null</code>)
3212            * @param newPassword2 the user's new password confirmation (optionally
3213            <code>null</code>)
3214            * @param passwordReset whether the user should be asked to reset their
3215            password the next time they login
3216            * @param reminderQueryQuestion the user's new password reset question
3217            * @param reminderQueryAnswer the user's new password reset answer
3218            * @param screenName the user's new screen name
3219            * @param emailAddress the user's new email address
3220            * @param facebookId the user's new Facebook ID
3221            * @param openId the user's new OpenID
3222            * @param languageId the user's new language ID
3223            * @param timeZoneId the user's new time zone ID
3224            * @param greeting the user's new greeting
3225            * @param comments the user's new comments
3226            * @param firstName the user's new first name
3227            * @param middleName the user's new middle name
3228            * @param lastName the user's new last name
3229            * @param prefixId the user's new name prefix ID
3230            * @param suffixId the user's new name suffix ID
3231            * @param male whether user is male
3232            * @param birthdayMonth the user's new birthday month (0-based, meaning
3233            0 for January)
3234            * @param birthdayDay the user's new birthday day
3235            * @param birthdayYear the user's birthday year
3236            * @param smsSn the user's new SMS screen name
3237            * @param aimSn the user's new AIM screen name
3238            * @param facebookSn the user's new Facebook screen name
3239            * @param icqSn the user's new ICQ screen name
3240            * @param jabberSn the user's new Jabber screen name
3241            * @param msnSn the user's new MSN screen name
3242            * @param mySpaceSn the user's new MySpace screen name
3243            * @param skypeSn the user's new Skype screen name
3244            * @param twitterSn the user's new Twitter screen name
3245            * @param ymSn the user's new Yahoo! Messenger screen name
3246            * @param jobTitle the user's new job title
3247            * @param groupIds the primary keys of the user's groups
3248            * @param organizationIds the primary keys of the user's organizations
3249            * @param roleIds the primary keys of the user's roles
3250            * @param userGroupRoles the user user's group roles
3251            * @param userGroupIds the primary keys of the user's user groups
3252            * @param serviceContext the service context to be applied (optionally
3253            <code>null</code>). Can set the UUID (with the
3254            <code>uuid</code> attribute), asset category IDs, asset tag
3255            names, and expando bridge attributes for the user.
3256            * @return the user
3257            * @throws PortalException if a user with the primary key could not be
3258            found or if the new information was invalid
3259            * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String,
3260            String, String, boolean, String, String, String, String,
3261            long, String, String, String, String, String, String, String,
3262            String, int, int, boolean, int, int, int, String, String,
3263            String, String, String, String, String, String, String,
3264            String, String, long[], long[], long[], java.util.List,
3265            long[], boolean, byte[], ServiceContext)}
3266            */
3267            @Deprecated
3268            @Override
3269            public com.liferay.portal.model.User updateUser(long userId,
3270                    java.lang.String oldPassword, java.lang.String newPassword1,
3271                    java.lang.String newPassword2, boolean passwordReset,
3272                    java.lang.String reminderQueryQuestion,
3273                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3274                    java.lang.String emailAddress, long facebookId,
3275                    java.lang.String openId, java.lang.String languageId,
3276                    java.lang.String timeZoneId, java.lang.String greeting,
3277                    java.lang.String comments, java.lang.String firstName,
3278                    java.lang.String middleName, java.lang.String lastName, int prefixId,
3279                    int suffixId, boolean male, int birthdayMonth, int birthdayDay,
3280                    int birthdayYear, java.lang.String smsSn, java.lang.String aimSn,
3281                    java.lang.String facebookSn, java.lang.String icqSn,
3282                    java.lang.String jabberSn, java.lang.String msnSn,
3283                    java.lang.String mySpaceSn, java.lang.String skypeSn,
3284                    java.lang.String twitterSn, java.lang.String ymSn,
3285                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
3286                    long[] roleIds,
3287                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3288                    long[] userGroupIds,
3289                    com.liferay.portal.service.ServiceContext serviceContext)
3290                    throws com.liferay.portal.kernel.exception.PortalException {
3291                    return _userLocalService.updateUser(userId, oldPassword, newPassword1,
3292                            newPassword2, passwordReset, reminderQueryQuestion,
3293                            reminderQueryAnswer, screenName, emailAddress, facebookId, openId,
3294                            languageId, timeZoneId, greeting, comments, firstName, middleName,
3295                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
3296                            birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn, msnSn,
3297                            mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle, groupIds,
3298                            organizationIds, roleIds, userGroupRoles, userGroupIds,
3299                            serviceContext);
3300            }
3301    
3302            /**
3303            * Updates the user.
3304            *
3305            * @param userId the primary key of the user
3306            * @param oldPassword the user's old password
3307            * @param newPassword1 the user's new password (optionally
3308            <code>null</code>)
3309            * @param newPassword2 the user's new password confirmation (optionally
3310            <code>null</code>)
3311            * @param passwordReset whether the user should be asked to reset their
3312            password the next time they login
3313            * @param reminderQueryQuestion the user's new password reset question
3314            * @param reminderQueryAnswer the user's new password reset answer
3315            * @param screenName the user's new screen name
3316            * @param emailAddress the user's new email address
3317            * @param facebookId the user's new Facebook ID
3318            * @param openId the user's new OpenID
3319            * @param portrait whether to update the user's portrait image
3320            * @param portraitBytes the new portrait image data
3321            * @param languageId the user's new language ID
3322            * @param timeZoneId the user's new time zone ID
3323            * @param greeting the user's new greeting
3324            * @param comments the user's new comments
3325            * @param firstName the user's new first name
3326            * @param middleName the user's new middle name
3327            * @param lastName the user's new last name
3328            * @param prefixId the user's new name prefix ID
3329            * @param suffixId the user's new name suffix ID
3330            * @param male whether user is male
3331            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
3332            for January)
3333            * @param birthdayDay the user's new birthday day
3334            * @param birthdayYear the user's birthday year
3335            * @param smsSn the user's new SMS screen name
3336            * @param aimSn the user's new AIM screen name
3337            * @param facebookSn the user's new Facebook screen name
3338            * @param icqSn the user's new ICQ screen name
3339            * @param jabberSn the user's new Jabber screen name
3340            * @param msnSn the user's new MSN screen name
3341            * @param mySpaceSn the user's new MySpace screen name
3342            * @param skypeSn the user's new Skype screen name
3343            * @param twitterSn the user's new Twitter screen name
3344            * @param ymSn the user's new Yahoo! Messenger screen name
3345            * @param jobTitle the user's new job title
3346            * @param groupIds the primary keys of the user's groups
3347            * @param organizationIds the primary keys of the user's organizations
3348            * @param roleIds the primary keys of the user's roles
3349            * @param userGroupRoles the user user's group roles
3350            * @param userGroupIds the primary keys of the user's user groups
3351            * @param serviceContext the service context to be applied (optionally
3352            <code>null</code>). Can set the UUID (with the <code>uuid</code>
3353            attribute), asset category IDs, asset tag names, and expando
3354            bridge attributes for the user.
3355            * @return the user
3356            * @throws PortalException if a user with the primary key could not be found
3357            or if the new information was invalid
3358            */
3359            @Override
3360            public com.liferay.portal.model.User updateUser(long userId,
3361                    java.lang.String oldPassword, java.lang.String newPassword1,
3362                    java.lang.String newPassword2, boolean passwordReset,
3363                    java.lang.String reminderQueryQuestion,
3364                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3365                    java.lang.String emailAddress, long facebookId,
3366                    java.lang.String openId, boolean portrait, byte[] portraitBytes,
3367                    java.lang.String languageId, java.lang.String timeZoneId,
3368                    java.lang.String greeting, java.lang.String comments,
3369                    java.lang.String firstName, java.lang.String middleName,
3370                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
3371                    int birthdayMonth, int birthdayDay, int birthdayYear,
3372                    java.lang.String smsSn, java.lang.String aimSn,
3373                    java.lang.String facebookSn, java.lang.String icqSn,
3374                    java.lang.String jabberSn, java.lang.String msnSn,
3375                    java.lang.String mySpaceSn, java.lang.String skypeSn,
3376                    java.lang.String twitterSn, java.lang.String ymSn,
3377                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
3378                    long[] roleIds,
3379                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3380                    long[] userGroupIds,
3381                    com.liferay.portal.service.ServiceContext serviceContext)
3382                    throws com.liferay.portal.kernel.exception.PortalException {
3383                    return _userLocalService.updateUser(userId, oldPassword, newPassword1,
3384                            newPassword2, passwordReset, reminderQueryQuestion,
3385                            reminderQueryAnswer, screenName, emailAddress, facebookId, openId,
3386                            portrait, portraitBytes, languageId, timeZoneId, greeting,
3387                            comments, firstName, middleName, lastName, prefixId, suffixId,
3388                            male, birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn,
3389                            facebookSn, icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn,
3390                            ymSn, jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
3391                            userGroupIds, serviceContext);
3392            }
3393    
3394            /**
3395            * Verifies the email address of the ticket.
3396            *
3397            * @param ticketKey the ticket key
3398            * @throws PortalException if a ticket matching the ticket key could not be
3399            found, if the ticket has expired, if the ticket is an email
3400            address ticket, or if the email address is invalid
3401            */
3402            @Override
3403            public void verifyEmailAddress(java.lang.String ticketKey)
3404                    throws com.liferay.portal.kernel.exception.PortalException {
3405                    _userLocalService.verifyEmailAddress(ticketKey);
3406            }
3407    
3408            /**
3409             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
3410             */
3411            @Deprecated
3412            public UserLocalService getWrappedUserLocalService() {
3413                    return _userLocalService;
3414            }
3415    
3416            /**
3417             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
3418             */
3419            @Deprecated
3420            public void setWrappedUserLocalService(UserLocalService userLocalService) {
3421                    _userLocalService = userLocalService;
3422            }
3423    
3424            @Override
3425            public UserLocalService getWrappedService() {
3426                    return _userLocalService;
3427            }
3428    
3429            @Override
3430            public void setWrappedService(UserLocalService userLocalService) {
3431                    _userLocalService = userLocalService;
3432            }
3433    
3434            private UserLocalService _userLocalService;
3435    }