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