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 that match the dynamic query.
987            *
988            * @param dynamicQuery the dynamic query
989            * @return the number of rows that match 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 that match 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 that match 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            /**
2240            * Returns an ordered range of all the users who match the keywords and
2241            * status, without using the indexer. It is preferable to use the indexed
2242            * version {@link #search(long, String, int, LinkedHashMap, int, int, Sort)}
2243            * instead of this method wherever possible for performance reasons.
2244            *
2245            * <p>
2246            * Useful when paginating results. Returns a maximum of <code>end -
2247            * start</code> instances. <code>start</code> and <code>end</code> are not
2248            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2249            * refers to the first result in the set. Setting both <code>start</code>
2250            * and <code>end</code> to {@link
2251            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
2252            * result set.
2253            * </p>
2254            *
2255            * @param companyId the primary key of the user's company
2256            * @param keywords the keywords (space separated), which may occur in the
2257            user's first name, middle name, last name, screen name, or email
2258            address
2259            * @param status the workflow status
2260            * @param params the finder parameters (optionally <code>null</code>). For
2261            more information see {@link
2262            com.liferay.portal.service.persistence.UserFinder}.
2263            * @param start the lower bound of the range of users
2264            * @param end the upper bound of the range of users (not inclusive)
2265            * @param obc the comparator to order the users by (optionally
2266            <code>null</code>)
2267            * @return the matching users
2268            * @see com.liferay.portal.service.persistence.UserFinder
2269            */
2270            @Override
2271            public java.util.List<com.liferay.portal.model.User> search(
2272                    long companyId, java.lang.String keywords, int status,
2273                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2274                    int start, int end,
2275                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) {
2276                    return _userLocalService.search(companyId, keywords, status, params,
2277                            start, end, obc);
2278            }
2279    
2280            /**
2281            * Returns an ordered range of all the users who match the keywords and
2282            * status, using the indexer. It is preferable to use this method instead of
2283            * the non-indexed version whenever possible for performance reasons.
2284            *
2285            * <p>
2286            * Useful when paginating results. Returns a maximum of <code>end -
2287            * start</code> instances. <code>start</code> and <code>end</code> are not
2288            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2289            * refers to the first result in the set. Setting both <code>start</code>
2290            * and <code>end</code> to {@link
2291            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
2292            * result set.
2293            * </p>
2294            *
2295            * @param companyId the primary key of the user's company
2296            * @param keywords the keywords (space separated), which may occur in the
2297            user's first name, middle name, last name, screen name, or email
2298            address
2299            * @param status the workflow status
2300            * @param params the indexer parameters (optionally <code>null</code>). For
2301            more information see {@link
2302            com.liferay.portlet.usersadmin.util.UserIndexer}.
2303            * @param start the lower bound of the range of users
2304            * @param end the upper bound of the range of users (not inclusive)
2305            * @param sort the field and direction to sort by (optionally
2306            <code>null</code>)
2307            * @return the matching users
2308            * @see com.liferay.portlet.usersadmin.util.UserIndexer
2309            */
2310            @Override
2311            public com.liferay.portal.kernel.search.Hits search(long companyId,
2312                    java.lang.String keywords, int status,
2313                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2314                    int start, int end, com.liferay.portal.kernel.search.Sort sort) {
2315                    return _userLocalService.search(companyId, keywords, status, params,
2316                            start, end, sort);
2317            }
2318    
2319            /**
2320            * Returns the number of users with the status, and whose first name, middle
2321            * name, last name, screen name, and email address match the keywords
2322            * specified for them.
2323            *
2324            * @param companyId the primary key of the user's company
2325            * @param firstName the first name keywords (space separated)
2326            * @param middleName the middle name keywords
2327            * @param lastName the last name keywords
2328            * @param screenName the screen name keywords
2329            * @param emailAddress the email address keywords
2330            * @param status the workflow status
2331            * @param params the finder parameters (optionally <code>null</code>). For
2332            more information see {@link
2333            com.liferay.portal.service.persistence.UserFinder}.
2334            * @param andSearch whether every field must match its keywords, or just
2335            one field. For example, &quot;users with the first name 'bob' and
2336            last name 'smith'&quot; vs &quot;users with the first name 'bob'
2337            or the last name 'smith'&quot;.
2338            * @return the number of matching users
2339            */
2340            @Override
2341            public int searchCount(long companyId, java.lang.String firstName,
2342                    java.lang.String middleName, java.lang.String lastName,
2343                    java.lang.String screenName, java.lang.String emailAddress, int status,
2344                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2345                    boolean andSearch) {
2346                    return _userLocalService.searchCount(companyId, firstName, middleName,
2347                            lastName, screenName, emailAddress, status, params, andSearch);
2348            }
2349    
2350            /**
2351            * Returns the number of users who match the keywords and status.
2352            *
2353            * @param companyId the primary key of the user's company
2354            * @param keywords the keywords (space separated), which may occur in the
2355            user's first name, middle name, last name, screen name, or email
2356            address
2357            * @param status the workflow status
2358            * @param params the finder parameters (optionally <code>null</code>). For
2359            more information see {@link
2360            com.liferay.portal.service.persistence.UserFinder}.
2361            * @return the number matching users
2362            */
2363            @Override
2364            public int searchCount(long companyId, java.lang.String keywords,
2365                    int status,
2366                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2367                    return _userLocalService.searchCount(companyId, keywords, status, params);
2368            }
2369    
2370            @Override
2371            public java.util.List<com.liferay.portal.model.User> searchSocial(
2372                    long companyId, long[] groupIds, java.lang.String keywords, int start,
2373                    int end) {
2374                    return _userLocalService.searchSocial(companyId, groupIds, keywords,
2375                            start, end);
2376            }
2377    
2378            @Override
2379            public java.util.List<com.liferay.portal.model.User> searchSocial(
2380                    long[] groupIds, long userId, int[] socialRelationTypes,
2381                    java.lang.String keywords, int start, int end)
2382                    throws com.liferay.portal.kernel.exception.PortalException {
2383                    return _userLocalService.searchSocial(groupIds, userId,
2384                            socialRelationTypes, keywords, start, end);
2385            }
2386    
2387            @Override
2388            public java.util.List<com.liferay.portal.model.User> searchSocial(
2389                    long userId, int[] socialRelationTypes, java.lang.String keywords,
2390                    int start, int end)
2391                    throws com.liferay.portal.kernel.exception.PortalException {
2392                    return _userLocalService.searchSocial(userId, socialRelationTypes,
2393                            keywords, start, end);
2394            }
2395    
2396            @Override
2397            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2398                    long companyId, java.lang.String firstName,
2399                    java.lang.String middleName, java.lang.String lastName,
2400                    java.lang.String screenName, java.lang.String emailAddress, int status,
2401                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2402                    boolean andSearch, int start, int end,
2403                    com.liferay.portal.kernel.search.Sort sort)
2404                    throws com.liferay.portal.kernel.exception.PortalException {
2405                    return _userLocalService.searchUsers(companyId, firstName, middleName,
2406                            lastName, screenName, emailAddress, status, params, andSearch,
2407                            start, end, sort);
2408            }
2409    
2410            @Override
2411            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2412                    long companyId, java.lang.String keywords, int status,
2413                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2414                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
2415                    throws com.liferay.portal.kernel.exception.PortalException {
2416                    return _userLocalService.searchUsers(companyId, keywords, status,
2417                            params, start, end, sort);
2418            }
2419    
2420            /**
2421            * Sends an email address verification to the user.
2422            *
2423            * @param user the verification email recipient
2424            * @param emailAddress the recipient's email address
2425            * @param serviceContext the service context to be applied. Must set the
2426            portal URL, main path, primary key of the layout, remote address,
2427            remote host, and agent for the user.
2428            * @throws PortalException if a portal exception occurred
2429            */
2430            @Override
2431            public void sendEmailAddressVerification(
2432                    com.liferay.portal.model.User user, java.lang.String emailAddress,
2433                    com.liferay.portal.service.ServiceContext serviceContext)
2434                    throws com.liferay.portal.kernel.exception.PortalException {
2435                    _userLocalService.sendEmailAddressVerification(user, emailAddress,
2436                            serviceContext);
2437            }
2438    
2439            /**
2440            * Sends the password email to the user with the email address. The content
2441            * of this email can be specified in <code>portal.properties</code> with the
2442            * <code>admin.email.password</code> keys.
2443            *
2444            * @param companyId the primary key of the user's company
2445            * @param emailAddress the user's email address
2446            * @param fromName the name of the individual that the email should be from
2447            * @param fromAddress the address of the individual that the email should
2448            be from
2449            * @param subject the email subject. If <code>null</code>, the subject
2450            specified in <code>portal.properties</code> will be used.
2451            * @param body the email body. If <code>null</code>, the body specified in
2452            <code>portal.properties</code> will be used.
2453            * @param serviceContext the service context to be applied
2454            * @throws PortalException if a user with the email address could not be
2455            found
2456            */
2457            @Override
2458            public boolean sendPassword(long companyId, java.lang.String emailAddress,
2459                    java.lang.String fromName, java.lang.String fromAddress,
2460                    java.lang.String subject, java.lang.String body,
2461                    com.liferay.portal.service.ServiceContext serviceContext)
2462                    throws com.liferay.portal.kernel.exception.PortalException {
2463                    return _userLocalService.sendPassword(companyId, emailAddress,
2464                            fromName, fromAddress, subject, body, serviceContext);
2465            }
2466    
2467            @Override
2468            public boolean sendPasswordByEmailAddress(long companyId,
2469                    java.lang.String emailAddress)
2470                    throws com.liferay.portal.kernel.exception.PortalException {
2471                    return _userLocalService.sendPasswordByEmailAddress(companyId,
2472                            emailAddress);
2473            }
2474    
2475            @Override
2476            public boolean sendPasswordByScreenName(long companyId,
2477                    java.lang.String screenName)
2478                    throws com.liferay.portal.kernel.exception.PortalException {
2479                    return _userLocalService.sendPasswordByScreenName(companyId, screenName);
2480            }
2481    
2482            @Override
2483            public boolean sendPasswordByUserId(long userId)
2484                    throws com.liferay.portal.kernel.exception.PortalException {
2485                    return _userLocalService.sendPasswordByUserId(userId);
2486            }
2487    
2488            /**
2489            * Sets the Spring bean ID for this bean.
2490            *
2491            * @param beanIdentifier the Spring bean ID for this bean
2492            */
2493            @Override
2494            public void setBeanIdentifier(java.lang.String beanIdentifier) {
2495                    _userLocalService.setBeanIdentifier(beanIdentifier);
2496            }
2497    
2498            @Override
2499            public void setGroupUsers(long groupId, long[] userIds) {
2500                    _userLocalService.setGroupUsers(groupId, userIds);
2501            }
2502    
2503            @Override
2504            public void setOrganizationUsers(long organizationId, long[] userIds) {
2505                    _userLocalService.setOrganizationUsers(organizationId, userIds);
2506            }
2507    
2508            /**
2509            * @throws PortalException
2510            */
2511            @Override
2512            public void setRoleUsers(long roleId, long[] userIds)
2513                    throws com.liferay.portal.kernel.exception.PortalException {
2514                    _userLocalService.setRoleUsers(roleId, userIds);
2515            }
2516    
2517            @Override
2518            public void setTeamUsers(long teamId, long[] userIds) {
2519                    _userLocalService.setTeamUsers(teamId, userIds);
2520            }
2521    
2522            /**
2523            * @throws PortalException
2524            */
2525            @Override
2526            public void setUserGroupUsers(long userGroupId, long[] userIds)
2527                    throws com.liferay.portal.kernel.exception.PortalException {
2528                    _userLocalService.setUserGroupUsers(userGroupId, userIds);
2529            }
2530    
2531            /**
2532            * Removes the users from the teams of a group.
2533            *
2534            * @param groupId the primary key of the group
2535            * @param userIds the primary keys of the users
2536            * @throws PortalException if a portal exception occurred
2537            */
2538            @Override
2539            public void unsetGroupTeamsUsers(long groupId, long[] userIds)
2540                    throws com.liferay.portal.kernel.exception.PortalException {
2541                    _userLocalService.unsetGroupTeamsUsers(groupId, userIds);
2542            }
2543    
2544            /**
2545            * Removes the users from the group.
2546            *
2547            * @param groupId the primary key of the group
2548            * @param userIds the primary keys of the users
2549            * @param serviceContext the service context to be applied (optionally
2550            <code>null</code>)
2551            * @throws PortalException if a portal exception occurred
2552            */
2553            @Override
2554            public void unsetGroupUsers(long groupId, long[] userIds,
2555                    com.liferay.portal.service.ServiceContext serviceContext)
2556                    throws com.liferay.portal.kernel.exception.PortalException {
2557                    _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext);
2558            }
2559    
2560            /**
2561            * Removes the users from the organization.
2562            *
2563            * @param organizationId the primary key of the organization
2564            * @param userIds the primary keys of the users
2565            * @throws PortalException if a portal exception occurred
2566            */
2567            @Override
2568            public void unsetOrganizationUsers(long organizationId, long[] userIds)
2569                    throws com.liferay.portal.kernel.exception.PortalException {
2570                    _userLocalService.unsetOrganizationUsers(organizationId, userIds);
2571            }
2572    
2573            /**
2574            * Removes the users from the password policy.
2575            *
2576            * @param passwordPolicyId the primary key of the password policy
2577            * @param userIds the primary keys of the users
2578            */
2579            @Override
2580            public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds) {
2581                    _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
2582            }
2583    
2584            /**
2585            * Removes the users from the role.
2586            *
2587            * @param roleId the primary key of the role
2588            * @param userIds the primary keys of the users
2589            * @throws PortalException if a portal exception occurred
2590            */
2591            @Override
2592            public void unsetRoleUsers(long roleId, long[] userIds)
2593                    throws com.liferay.portal.kernel.exception.PortalException {
2594                    _userLocalService.unsetRoleUsers(roleId, userIds);
2595            }
2596    
2597            /**
2598            * Removes the users from the role.
2599            *
2600            * @param roleId the primary key of the role
2601            * @param users the users
2602            * @throws PortalException if a portal exception occurred
2603            */
2604            @Override
2605            public void unsetRoleUsers(long roleId,
2606                    java.util.List<com.liferay.portal.model.User> users)
2607                    throws com.liferay.portal.kernel.exception.PortalException {
2608                    _userLocalService.unsetRoleUsers(roleId, users);
2609            }
2610    
2611            /**
2612            * Removes the users from the team.
2613            *
2614            * @param teamId the primary key of the team
2615            * @param userIds the primary keys of the users
2616            * @throws PortalException if a portal exception occurred
2617            */
2618            @Override
2619            public void unsetTeamUsers(long teamId, long[] userIds)
2620                    throws com.liferay.portal.kernel.exception.PortalException {
2621                    _userLocalService.unsetTeamUsers(teamId, userIds);
2622            }
2623    
2624            /**
2625            * Removes the users from the user group.
2626            *
2627            * @param userGroupId the primary key of the user group
2628            * @param userIds the primary keys of the users
2629            * @throws PortalException if a portal exception occurred
2630            */
2631            @Override
2632            public void unsetUserGroupUsers(long userGroupId, long[] userIds)
2633                    throws com.liferay.portal.kernel.exception.PortalException {
2634                    _userLocalService.unsetUserGroupUsers(userGroupId, userIds);
2635            }
2636    
2637            /**
2638            * Updates whether the user has agreed to the terms of use.
2639            *
2640            * @param userId the primary key of the user
2641            * @param agreedToTermsOfUse whether the user has agreet to the terms of
2642            use
2643            * @return the user
2644            * @throws PortalException if a user with the primary key could not be found
2645            */
2646            @Override
2647            public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId,
2648                    boolean agreedToTermsOfUse)
2649                    throws com.liferay.portal.kernel.exception.PortalException {
2650                    return _userLocalService.updateAgreedToTermsOfUse(userId,
2651                            agreedToTermsOfUse);
2652            }
2653    
2654            /**
2655            * Updates the user's asset with the new asset categories and tag names,
2656            * removing and adding asset categories and tag names as necessary.
2657            *
2658            * @param userId the primary key of the user
2659            * @param user ID the primary key of the user
2660            * @param assetCategoryIds the primary key's of the new asset categories
2661            * @param assetTagNames the new asset tag names
2662            * @throws PortalException if a user with the primary key could not be found
2663            */
2664            @Override
2665            public void updateAsset(long userId, com.liferay.portal.model.User user,
2666                    long[] assetCategoryIds, java.lang.String[] assetTagNames)
2667                    throws com.liferay.portal.kernel.exception.PortalException {
2668                    _userLocalService.updateAsset(userId, user, assetCategoryIds,
2669                            assetTagNames);
2670            }
2671    
2672            /**
2673            * Updates the user's creation date.
2674            *
2675            * @param userId the primary key of the user
2676            * @param createDate the new creation date
2677            * @return the user
2678            * @throws PortalException if a user with the primary key could not be found
2679            */
2680            @Override
2681            public com.liferay.portal.model.User updateCreateDate(long userId,
2682                    java.util.Date createDate)
2683                    throws com.liferay.portal.kernel.exception.PortalException {
2684                    return _userLocalService.updateCreateDate(userId, createDate);
2685            }
2686    
2687            /**
2688            * Updates the user's email address.
2689            *
2690            * @param userId the primary key of the user
2691            * @param password the user's password
2692            * @param emailAddress1 the user's new email address
2693            * @param emailAddress2 the user's new email address confirmation
2694            * @return the user
2695            * @throws PortalException if a user with the primary key could not be found
2696            */
2697            @Override
2698            public com.liferay.portal.model.User updateEmailAddress(long userId,
2699                    java.lang.String password, java.lang.String emailAddress1,
2700                    java.lang.String emailAddress2)
2701                    throws com.liferay.portal.kernel.exception.PortalException {
2702                    return _userLocalService.updateEmailAddress(userId, password,
2703                            emailAddress1, emailAddress2);
2704            }
2705    
2706            /**
2707            * Updates the user's email address or sends verification email.
2708            *
2709            * @param userId the primary key of the user
2710            * @param password the user's password
2711            * @param emailAddress1 the user's new email address
2712            * @param emailAddress2 the user's new email address confirmation
2713            * @param serviceContext the service context to be applied. Must set the
2714            portal URL, main path, primary key of the layout, remote address,
2715            remote host, and agent for the user.
2716            * @return the user
2717            * @throws PortalException if a user with the primary key could not be found
2718            */
2719            @Override
2720            public com.liferay.portal.model.User updateEmailAddress(long userId,
2721                    java.lang.String password, java.lang.String emailAddress1,
2722                    java.lang.String emailAddress2,
2723                    com.liferay.portal.service.ServiceContext serviceContext)
2724                    throws com.liferay.portal.kernel.exception.PortalException {
2725                    return _userLocalService.updateEmailAddress(userId, password,
2726                            emailAddress1, emailAddress2, serviceContext);
2727            }
2728    
2729            /**
2730            * Updates whether the user has verified email address.
2731            *
2732            * @param userId the primary key of the user
2733            * @param emailAddressVerified whether the user has verified email address
2734            * @return the user
2735            * @throws PortalException if a user with the primary key could not be found
2736            */
2737            @Override
2738            public com.liferay.portal.model.User updateEmailAddressVerified(
2739                    long userId, boolean emailAddressVerified)
2740                    throws com.liferay.portal.kernel.exception.PortalException {
2741                    return _userLocalService.updateEmailAddressVerified(userId,
2742                            emailAddressVerified);
2743            }
2744    
2745            /**
2746            * Updates the user's Facebook ID.
2747            *
2748            * @param userId the primary key of the user
2749            * @param facebookId the user's new Facebook ID
2750            * @return the user
2751            * @throws PortalException if a user with the primary key could not be found
2752            */
2753            @Override
2754            public com.liferay.portal.model.User updateFacebookId(long userId,
2755                    long facebookId)
2756                    throws com.liferay.portal.kernel.exception.PortalException {
2757                    return _userLocalService.updateFacebookId(userId, facebookId);
2758            }
2759    
2760            /**
2761            * Sets the groups the user is in, removing and adding groups as necessary.
2762            *
2763            * @param userId the primary key of the user
2764            * @param newGroupIds the primary keys of the groups
2765            * @param serviceContext the service context to be applied (optionally
2766            <code>null</code>)
2767            * @throws PortalException if a portal exception occurred
2768            */
2769            @Override
2770            public void updateGroups(long userId, long[] newGroupIds,
2771                    com.liferay.portal.service.ServiceContext serviceContext)
2772                    throws com.liferay.portal.kernel.exception.PortalException {
2773                    _userLocalService.updateGroups(userId, newGroupIds, serviceContext);
2774            }
2775    
2776            /**
2777            * Updates a user account that was automatically created when a guest user
2778            * participated in an action (e.g. posting a comment) and only provided his
2779            * name and email address.
2780            *
2781            * @param creatorUserId the primary key of the creator
2782            * @param companyId the primary key of the user's company
2783            * @param autoPassword whether a password should be automatically generated
2784            for the user
2785            * @param password1 the user's password
2786            * @param password2 the user's password confirmation
2787            * @param autoScreenName whether a screen name should be automatically
2788            generated for the user
2789            * @param screenName the user's screen name
2790            * @param emailAddress the user's email address
2791            * @param facebookId the user's facebook ID
2792            * @param openId the user's OpenID
2793            * @param locale the user's locale
2794            * @param firstName the user's first name
2795            * @param middleName the user's middle name
2796            * @param lastName the user's last name
2797            * @param prefixId the user's name prefix ID
2798            * @param suffixId the user's name suffix ID
2799            * @param male whether the user is male
2800            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
2801            January)
2802            * @param birthdayDay the user's birthday day
2803            * @param birthdayYear the user's birthday year
2804            * @param jobTitle the user's job title
2805            * @param updateUserInformation whether to update the user's information
2806            * @param sendEmail whether to send the user an email notification about
2807            their new account
2808            * @param serviceContext the service context to be applied (optionally
2809            <code>null</code>). Can set expando bridge attributes for the
2810            user.
2811            * @return the user
2812            * @throws PortalException if the user's information was invalid
2813            */
2814            @Override
2815            public com.liferay.portal.model.User updateIncompleteUser(
2816                    long creatorUserId, long companyId, boolean autoPassword,
2817                    java.lang.String password1, java.lang.String password2,
2818                    boolean autoScreenName, java.lang.String screenName,
2819                    java.lang.String emailAddress, long facebookId,
2820                    java.lang.String openId, java.util.Locale locale,
2821                    java.lang.String firstName, java.lang.String middleName,
2822                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
2823                    int birthdayMonth, int birthdayDay, int birthdayYear,
2824                    java.lang.String jobTitle, boolean updateUserInformation,
2825                    boolean sendEmail,
2826                    com.liferay.portal.service.ServiceContext serviceContext)
2827                    throws com.liferay.portal.kernel.exception.PortalException {
2828                    return _userLocalService.updateIncompleteUser(creatorUserId, companyId,
2829                            autoPassword, password1, password2, autoScreenName, screenName,
2830                            emailAddress, facebookId, openId, locale, firstName, middleName,
2831                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
2832                            birthdayYear, jobTitle, updateUserInformation, sendEmail,
2833                            serviceContext);
2834            }
2835    
2836            /**
2837            * Updates the user's job title.
2838            *
2839            * @param userId the primary key of the user
2840            * @param jobTitle the user's job title
2841            * @return the user
2842            * @throws PortalException if a user with the primary key could not be found
2843            or if a contact could not be found matching the user's contact ID
2844            */
2845            @Override
2846            public com.liferay.portal.model.User updateJobTitle(long userId,
2847                    java.lang.String jobTitle)
2848                    throws com.liferay.portal.kernel.exception.PortalException {
2849                    return _userLocalService.updateJobTitle(userId, jobTitle);
2850            }
2851    
2852            /**
2853            * Updates the user's last login with the current time and the IP address.
2854            *
2855            * @param userId the primary key of the user
2856            * @param loginIP the IP address the user logged in from
2857            * @return the user
2858            * @throws PortalException if a user with the primary key could not be found
2859            */
2860            @Override
2861            public com.liferay.portal.model.User updateLastLogin(long userId,
2862                    java.lang.String loginIP)
2863                    throws com.liferay.portal.kernel.exception.PortalException {
2864                    return _userLocalService.updateLastLogin(userId, loginIP);
2865            }
2866    
2867            /**
2868            * Updates whether the user is locked out from logging in.
2869            *
2870            * @param user the user
2871            * @param lockout whether the user is locked out
2872            * @return the user
2873            * @throws PortalException if a portal exception occurred
2874            */
2875            @Override
2876            public com.liferay.portal.model.User updateLockout(
2877                    com.liferay.portal.model.User user, boolean lockout)
2878                    throws com.liferay.portal.kernel.exception.PortalException {
2879                    return _userLocalService.updateLockout(user, lockout);
2880            }
2881    
2882            /**
2883            * Updates whether the user is locked out from logging in.
2884            *
2885            * @param companyId the primary key of the user's company
2886            * @param emailAddress the user's email address
2887            * @param lockout whether the user is locked out
2888            * @return the user
2889            * @throws PortalException if a user with the email address could not be
2890            found
2891            */
2892            @Override
2893            public com.liferay.portal.model.User updateLockoutByEmailAddress(
2894                    long companyId, java.lang.String emailAddress, boolean lockout)
2895                    throws com.liferay.portal.kernel.exception.PortalException {
2896                    return _userLocalService.updateLockoutByEmailAddress(companyId,
2897                            emailAddress, lockout);
2898            }
2899    
2900            /**
2901            * Updates whether the user is locked out from logging in.
2902            *
2903            * @param userId the primary key of the user
2904            * @param lockout whether the user is locked out
2905            * @return the user
2906            * @throws PortalException if a user with the primary key could not be found
2907            */
2908            @Override
2909            public com.liferay.portal.model.User updateLockoutById(long userId,
2910                    boolean lockout)
2911                    throws com.liferay.portal.kernel.exception.PortalException {
2912                    return _userLocalService.updateLockoutById(userId, lockout);
2913            }
2914    
2915            /**
2916            * Updates whether the user is locked out from logging in.
2917            *
2918            * @param companyId the primary key of the user's company
2919            * @param screenName the user's screen name
2920            * @param lockout whether the user is locked out
2921            * @return the user
2922            * @throws PortalException if a user with the screen name could not be found
2923            */
2924            @Override
2925            public com.liferay.portal.model.User updateLockoutByScreenName(
2926                    long companyId, java.lang.String screenName, boolean lockout)
2927                    throws com.liferay.portal.kernel.exception.PortalException {
2928                    return _userLocalService.updateLockoutByScreenName(companyId,
2929                            screenName, lockout);
2930            }
2931    
2932            /**
2933            * Updates the user's modified date.
2934            *
2935            * @param userId the primary key of the user
2936            * @param modifiedDate the new modified date
2937            * @return the user
2938            * @throws PortalException if a user with the primary key could not be found
2939            */
2940            @Override
2941            public com.liferay.portal.model.User updateModifiedDate(long userId,
2942                    java.util.Date modifiedDate)
2943                    throws com.liferay.portal.kernel.exception.PortalException {
2944                    return _userLocalService.updateModifiedDate(userId, modifiedDate);
2945            }
2946    
2947            /**
2948            * Updates the user's OpenID.
2949            *
2950            * @param userId the primary key of the user
2951            * @param openId the new OpenID
2952            * @return the user
2953            * @throws PortalException if a user with the primary key could not be found
2954            */
2955            @Override
2956            public com.liferay.portal.model.User updateOpenId(long userId,
2957                    java.lang.String openId)
2958                    throws com.liferay.portal.kernel.exception.PortalException {
2959                    return _userLocalService.updateOpenId(userId, openId);
2960            }
2961    
2962            /**
2963            * Sets the organizations that the user is in, removing and adding
2964            * organizations as necessary.
2965            *
2966            * @param userId the primary key of the user
2967            * @param newOrganizationIds the primary keys of the organizations
2968            * @param serviceContext the service context to be applied. Must set
2969            whether user indexing is enabled.
2970            * @throws PortalException if a user with the primary key could not be found
2971            */
2972            @Override
2973            public void updateOrganizations(long userId, long[] newOrganizationIds,
2974                    com.liferay.portal.service.ServiceContext serviceContext)
2975                    throws com.liferay.portal.kernel.exception.PortalException {
2976                    _userLocalService.updateOrganizations(userId, newOrganizationIds,
2977                            serviceContext);
2978            }
2979    
2980            /**
2981            * Updates the user's password without tracking or validation of the change.
2982            *
2983            * @param userId the primary key of the user
2984            * @param password1 the user's new password
2985            * @param password2 the user's new password confirmation
2986            * @param passwordReset whether the user should be asked to reset their
2987            password the next time they log in
2988            * @return the user
2989            * @throws PortalException if a user with the primary key could not be found
2990            */
2991            @Override
2992            public com.liferay.portal.model.User updatePassword(long userId,
2993                    java.lang.String password1, java.lang.String password2,
2994                    boolean passwordReset)
2995                    throws com.liferay.portal.kernel.exception.PortalException {
2996                    return _userLocalService.updatePassword(userId, password1, password2,
2997                            passwordReset);
2998            }
2999    
3000            /**
3001            * Updates the user's password, optionally with tracking and validation of
3002            * the change.
3003            *
3004            * @param userId the primary key of the user
3005            * @param password1 the user's new password
3006            * @param password2 the user's new password confirmation
3007            * @param passwordReset whether the user should be asked to reset their
3008            password the next time they login
3009            * @param silentUpdate whether the password should be updated without being
3010            tracked, or validated. Primarily used for password imports.
3011            * @return the user
3012            * @throws PortalException if a user with the primary key could not be found
3013            */
3014            @Override
3015            public com.liferay.portal.model.User updatePassword(long userId,
3016                    java.lang.String password1, java.lang.String password2,
3017                    boolean passwordReset, boolean silentUpdate)
3018                    throws com.liferay.portal.kernel.exception.PortalException {
3019                    return _userLocalService.updatePassword(userId, password1, password2,
3020                            passwordReset, silentUpdate);
3021            }
3022    
3023            /**
3024            * Updates the user's password with manually input information. This method
3025            * should only be used when performing maintenance.
3026            *
3027            * @param userId the primary key of the user
3028            * @param password the user's new password
3029            * @param passwordEncrypted the user's new encrypted password
3030            * @param passwordReset whether the user should be asked to reset their
3031            password the next time they login
3032            * @param passwordModifiedDate the new password modified date
3033            * @return the user
3034            * @throws PortalException if a user with the primary key could not be found
3035            */
3036            @Override
3037            public com.liferay.portal.model.User updatePasswordManually(long userId,
3038                    java.lang.String password, boolean passwordEncrypted,
3039                    boolean passwordReset, java.util.Date passwordModifiedDate)
3040                    throws com.liferay.portal.kernel.exception.PortalException {
3041                    return _userLocalService.updatePasswordManually(userId, password,
3042                            passwordEncrypted, passwordReset, passwordModifiedDate);
3043            }
3044    
3045            /**
3046            * Updates whether the user should be asked to reset their password the next
3047            * time they login.
3048            *
3049            * @param userId the primary key of the user
3050            * @param passwordReset whether the user should be asked to reset their
3051            password the next time they login
3052            * @return the user
3053            * @throws PortalException if a user with the primary key could not be found
3054            */
3055            @Override
3056            public com.liferay.portal.model.User updatePasswordReset(long userId,
3057                    boolean passwordReset)
3058                    throws com.liferay.portal.kernel.exception.PortalException {
3059                    return _userLocalService.updatePasswordReset(userId, passwordReset);
3060            }
3061    
3062            /**
3063            * Updates the user's portrait image.
3064            *
3065            * @param userId the primary key of the user
3066            * @param bytes the new portrait image data
3067            * @return the user
3068            * @throws PortalException if a user with the primary key could not be found
3069            or if the new portrait was invalid
3070            */
3071            @Override
3072            public com.liferay.portal.model.User updatePortrait(long userId,
3073                    byte[] bytes)
3074                    throws com.liferay.portal.kernel.exception.PortalException {
3075                    return _userLocalService.updatePortrait(userId, bytes);
3076            }
3077    
3078            /**
3079            * Updates the user's password reset question and answer.
3080            *
3081            * @param userId the primary key of the user
3082            * @param question the user's new password reset question
3083            * @param answer the user's new password reset answer
3084            * @return the user
3085            * @throws PortalException if a user with the primary key could not be found
3086            or if the new question or answer were invalid
3087            */
3088            @Override
3089            public com.liferay.portal.model.User updateReminderQuery(long userId,
3090                    java.lang.String question, java.lang.String answer)
3091                    throws com.liferay.portal.kernel.exception.PortalException {
3092                    return _userLocalService.updateReminderQuery(userId, question, answer);
3093            }
3094    
3095            /**
3096            * Updates the user's screen name.
3097            *
3098            * @param userId the primary key of the user
3099            * @param screenName the user's new screen name
3100            * @return the user
3101            * @throws PortalException if a user with the primary key could not be found
3102            or if the new screen name was invalid
3103            */
3104            @Override
3105            public com.liferay.portal.model.User updateScreenName(long userId,
3106                    java.lang.String screenName)
3107                    throws com.liferay.portal.kernel.exception.PortalException {
3108                    return _userLocalService.updateScreenName(userId, screenName);
3109            }
3110    
3111            /**
3112            * Updates the user's workflow status.
3113            *
3114            * @param userId the primary key of the user
3115            * @param status the user's new workflow status
3116            * @return the user
3117            * @throws PortalException if a user with the primary key could not be
3118            found
3119            * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int,
3120            ServiceContext)}
3121            */
3122            @Deprecated
3123            @Override
3124            public com.liferay.portal.model.User updateStatus(long userId, int status)
3125                    throws com.liferay.portal.kernel.exception.PortalException {
3126                    return _userLocalService.updateStatus(userId, status);
3127            }
3128    
3129            /**
3130            * Updates the user's workflow status.
3131            *
3132            * @param userId the primary key of the user
3133            * @param status the user's new workflow status
3134            * @param serviceContext the service context to be applied. You can specify
3135            an unencrypted custom password (used by an LDAP listener) for the
3136            user via attribute <code>passwordUnencrypted</code>.
3137            * @return the user
3138            * @throws PortalException if a user with the primary key could not be found
3139            */
3140            @Override
3141            public com.liferay.portal.model.User updateStatus(long userId, int status,
3142                    com.liferay.portal.service.ServiceContext serviceContext)
3143                    throws com.liferay.portal.kernel.exception.PortalException {
3144                    return _userLocalService.updateStatus(userId, status, serviceContext);
3145            }
3146    
3147            /**
3148            * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
3149            *
3150            * @param user the user
3151            * @return the user that was updated
3152            */
3153            @Override
3154            public com.liferay.portal.model.User updateUser(
3155                    com.liferay.portal.model.User user) {
3156                    return _userLocalService.updateUser(user);
3157            }
3158    
3159            /**
3160            * Updates the user.
3161            *
3162            * @param userId the primary key of the user
3163            * @param oldPassword the user's old password
3164            * @param newPassword1 the user's new password (optionally
3165            <code>null</code>)
3166            * @param newPassword2 the user's new password confirmation (optionally
3167            <code>null</code>)
3168            * @param passwordReset whether the user should be asked to reset their
3169            password the next time they login
3170            * @param reminderQueryQuestion the user's new password reset question
3171            * @param reminderQueryAnswer the user's new password reset answer
3172            * @param screenName the user's new screen name
3173            * @param emailAddress the user's new email address
3174            * @param facebookId the user's new Facebook ID
3175            * @param openId the user's new OpenID
3176            * @param languageId the user's new language ID
3177            * @param timeZoneId the user's new time zone ID
3178            * @param greeting the user's new greeting
3179            * @param comments the user's new comments
3180            * @param firstName the user's new first name
3181            * @param middleName the user's new middle name
3182            * @param lastName the user's new last name
3183            * @param prefixId the user's new name prefix ID
3184            * @param suffixId the user's new name suffix ID
3185            * @param male whether user is male
3186            * @param birthdayMonth the user's new birthday month (0-based, meaning
3187            0 for January)
3188            * @param birthdayDay the user's new birthday day
3189            * @param birthdayYear the user's birthday year
3190            * @param smsSn the user's new SMS screen name
3191            * @param aimSn the user's new AIM screen name
3192            * @param facebookSn the user's new Facebook screen name
3193            * @param icqSn the user's new ICQ screen name
3194            * @param jabberSn the user's new Jabber screen name
3195            * @param msnSn the user's new MSN screen name
3196            * @param mySpaceSn the user's new MySpace screen name
3197            * @param skypeSn the user's new Skype screen name
3198            * @param twitterSn the user's new Twitter screen name
3199            * @param ymSn the user's new Yahoo! Messenger screen name
3200            * @param jobTitle the user's new job title
3201            * @param groupIds the primary keys of the user's groups
3202            * @param organizationIds the primary keys of the user's organizations
3203            * @param roleIds the primary keys of the user's roles
3204            * @param userGroupRoles the user user's group roles
3205            * @param userGroupIds the primary keys of the user's user groups
3206            * @param serviceContext the service context to be applied (optionally
3207            <code>null</code>). Can set the UUID (with the
3208            <code>uuid</code> attribute), asset category IDs, asset tag
3209            names, and expando bridge attributes for the user.
3210            * @return the user
3211            * @throws PortalException if a user with the primary key could not be
3212            found or if the new information was invalid
3213            * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String,
3214            String, String, boolean, String, String, String, String,
3215            long, String, String, String, String, String, String, String,
3216            String, int, int, boolean, int, int, int, String, String,
3217            String, String, String, String, String, String, String,
3218            String, String, long[], long[], long[], java.util.List,
3219            long[], boolean, byte[], ServiceContext)}
3220            */
3221            @Deprecated
3222            @Override
3223            public com.liferay.portal.model.User updateUser(long userId,
3224                    java.lang.String oldPassword, java.lang.String newPassword1,
3225                    java.lang.String newPassword2, boolean passwordReset,
3226                    java.lang.String reminderQueryQuestion,
3227                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3228                    java.lang.String emailAddress, long facebookId,
3229                    java.lang.String openId, java.lang.String languageId,
3230                    java.lang.String timeZoneId, java.lang.String greeting,
3231                    java.lang.String comments, java.lang.String firstName,
3232                    java.lang.String middleName, java.lang.String lastName, int prefixId,
3233                    int suffixId, boolean male, int birthdayMonth, int birthdayDay,
3234                    int birthdayYear, java.lang.String smsSn, java.lang.String aimSn,
3235                    java.lang.String facebookSn, java.lang.String icqSn,
3236                    java.lang.String jabberSn, java.lang.String msnSn,
3237                    java.lang.String mySpaceSn, java.lang.String skypeSn,
3238                    java.lang.String twitterSn, java.lang.String ymSn,
3239                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
3240                    long[] roleIds,
3241                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3242                    long[] userGroupIds,
3243                    com.liferay.portal.service.ServiceContext serviceContext)
3244                    throws com.liferay.portal.kernel.exception.PortalException {
3245                    return _userLocalService.updateUser(userId, oldPassword, newPassword1,
3246                            newPassword2, passwordReset, reminderQueryQuestion,
3247                            reminderQueryAnswer, screenName, emailAddress, facebookId, openId,
3248                            languageId, timeZoneId, greeting, comments, firstName, middleName,
3249                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
3250                            birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn, msnSn,
3251                            mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle, groupIds,
3252                            organizationIds, roleIds, userGroupRoles, userGroupIds,
3253                            serviceContext);
3254            }
3255    
3256            /**
3257            * Updates the user.
3258            *
3259            * @param userId the primary key of the user
3260            * @param oldPassword the user's old password
3261            * @param newPassword1 the user's new password (optionally
3262            <code>null</code>)
3263            * @param newPassword2 the user's new password confirmation (optionally
3264            <code>null</code>)
3265            * @param passwordReset whether the user should be asked to reset their
3266            password the next time they login
3267            * @param reminderQueryQuestion the user's new password reset question
3268            * @param reminderQueryAnswer the user's new password reset answer
3269            * @param screenName the user's new screen name
3270            * @param emailAddress the user's new email address
3271            * @param facebookId the user's new Facebook ID
3272            * @param openId the user's new OpenID
3273            * @param portrait whether to update the user's portrait image
3274            * @param portraitBytes the new portrait image data
3275            * @param languageId the user's new language ID
3276            * @param timeZoneId the user's new time zone ID
3277            * @param greeting the user's new greeting
3278            * @param comments the user's new comments
3279            * @param firstName the user's new first name
3280            * @param middleName the user's new middle name
3281            * @param lastName the user's new last name
3282            * @param prefixId the user's new name prefix ID
3283            * @param suffixId the user's new name suffix ID
3284            * @param male whether user is male
3285            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
3286            for January)
3287            * @param birthdayDay the user's new birthday day
3288            * @param birthdayYear the user's birthday year
3289            * @param smsSn the user's new SMS screen name
3290            * @param aimSn the user's new AIM screen name
3291            * @param facebookSn the user's new Facebook screen name
3292            * @param icqSn the user's new ICQ screen name
3293            * @param jabberSn the user's new Jabber screen name
3294            * @param msnSn the user's new MSN screen name
3295            * @param mySpaceSn the user's new MySpace screen name
3296            * @param skypeSn the user's new Skype screen name
3297            * @param twitterSn the user's new Twitter screen name
3298            * @param ymSn the user's new Yahoo! Messenger screen name
3299            * @param jobTitle the user's new job title
3300            * @param groupIds the primary keys of the user's groups
3301            * @param organizationIds the primary keys of the user's organizations
3302            * @param roleIds the primary keys of the user's roles
3303            * @param userGroupRoles the user user's group roles
3304            * @param userGroupIds the primary keys of the user's user groups
3305            * @param serviceContext the service context to be applied (optionally
3306            <code>null</code>). Can set the UUID (with the <code>uuid</code>
3307            attribute), asset category IDs, asset tag names, and expando
3308            bridge attributes for the user.
3309            * @return the user
3310            * @throws PortalException if a user with the primary key could not be found
3311            or if the new information was invalid
3312            */
3313            @Override
3314            public com.liferay.portal.model.User updateUser(long userId,
3315                    java.lang.String oldPassword, java.lang.String newPassword1,
3316                    java.lang.String newPassword2, boolean passwordReset,
3317                    java.lang.String reminderQueryQuestion,
3318                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3319                    java.lang.String emailAddress, long facebookId,
3320                    java.lang.String openId, boolean portrait, byte[] portraitBytes,
3321                    java.lang.String languageId, java.lang.String timeZoneId,
3322                    java.lang.String greeting, java.lang.String comments,
3323                    java.lang.String firstName, java.lang.String middleName,
3324                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
3325                    int birthdayMonth, int birthdayDay, int birthdayYear,
3326                    java.lang.String smsSn, java.lang.String aimSn,
3327                    java.lang.String facebookSn, java.lang.String icqSn,
3328                    java.lang.String jabberSn, java.lang.String msnSn,
3329                    java.lang.String mySpaceSn, java.lang.String skypeSn,
3330                    java.lang.String twitterSn, java.lang.String ymSn,
3331                    java.lang.String jobTitle, long[] groupIds, long[] organizationIds,
3332                    long[] roleIds,
3333                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3334                    long[] userGroupIds,
3335                    com.liferay.portal.service.ServiceContext serviceContext)
3336                    throws com.liferay.portal.kernel.exception.PortalException {
3337                    return _userLocalService.updateUser(userId, oldPassword, newPassword1,
3338                            newPassword2, passwordReset, reminderQueryQuestion,
3339                            reminderQueryAnswer, screenName, emailAddress, facebookId, openId,
3340                            portrait, portraitBytes, languageId, timeZoneId, greeting,
3341                            comments, firstName, middleName, lastName, prefixId, suffixId,
3342                            male, birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn,
3343                            facebookSn, icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn,
3344                            ymSn, jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
3345                            userGroupIds, serviceContext);
3346            }
3347    
3348            /**
3349            * Verifies the email address of the ticket.
3350            *
3351            * @param ticketKey the ticket key
3352            * @throws PortalException if a ticket matching the ticket key could not be
3353            found, if the ticket has expired, if the ticket is an email
3354            address ticket, or if the email address is invalid
3355            */
3356            @Override
3357            public void verifyEmailAddress(java.lang.String ticketKey)
3358                    throws com.liferay.portal.kernel.exception.PortalException {
3359                    _userLocalService.verifyEmailAddress(ticketKey);
3360            }
3361    
3362            /**
3363             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
3364             */
3365            @Deprecated
3366            public UserLocalService getWrappedUserLocalService() {
3367                    return _userLocalService;
3368            }
3369    
3370            /**
3371             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
3372             */
3373            @Deprecated
3374            public void setWrappedUserLocalService(UserLocalService userLocalService) {
3375                    _userLocalService = userLocalService;
3376            }
3377    
3378            @Override
3379            public UserLocalService getWrappedService() {
3380                    return _userLocalService;
3381            }
3382    
3383            @Override
3384            public void setWrappedService(UserLocalService userLocalService) {
3385                    _userLocalService = userLocalService;
3386            }
3387    
3388            private UserLocalService _userLocalService;
3389    }